databricks-sdk 0.56.0__py3-none-any.whl → 0.58.0__py3-none-any.whl

databricks/sdk/service/ml.py

@@ -21,30 +21,18 @@ _LOG = logging.getLogger("databricks.sdk")
 
 @dataclass
 class Activity:
-    """Activity recorded for the action."""
+    """For activities, this contains the activity recorded for the action. For comments, this contains
+    the comment details. For transition requests, this contains the transition request details."""
 
     activity_type: Optional[ActivityType] = None
-    """Type of activity. Valid values are: * `APPLIED_TRANSITION`: User applied the corresponding stage
-    transition.
-    
-    * `REQUESTED_TRANSITION`: User requested the corresponding stage transition.
-    
-    * `CANCELLED_REQUEST`: User cancelled an existing transition request.
-    
-    * `APPROVED_REQUEST`: User approved the corresponding stage transition.
-    
-    * `REJECTED_REQUEST`: User rejected the coressponding stage transition.
-    
-    * `SYSTEM_TRANSITION`: For events performed as a side effect, such as archiving existing model
-    versions in a stage."""
 
     comment: Optional[str] = None
-    """User-provided comment associated with the activity."""
+    """User-provided comment associated with the activity, comment, or transition request."""
 
     creation_timestamp: Optional[int] = None
     """Creation time of the object, as a Unix timestamp in milliseconds."""
 
-    from_stage: Optional[Stage] = None
+    from_stage: Optional[str] = None
     """Source stage of the transition (if the activity is stage transition related). Valid values are:
     
     * `None`: The initial stage of a model version.
@@ -66,7 +54,7 @@ class Activity:
     usually describes a side effect, such as a version being archived as part of another version's
     stage transition, and may not be returned for some activity types."""
 
-    to_stage: Optional[Stage] = None
+    to_stage: Optional[str] = None
     """Target stage of the transition (if the activity is stage transition related). Valid values are:
     
     * `None`: The initial stage of a model version.
@@ -90,7 +78,7 @@ class Activity:
         if self.creation_timestamp is not None:
             body["creation_timestamp"] = self.creation_timestamp
         if self.from_stage is not None:
-            body["from_stage"] = self.from_stage.value
+            body["from_stage"] = self.from_stage
         if self.id is not None:
             body["id"] = self.id
         if self.last_updated_timestamp is not None:
@@ -98,7 +86,7 @@ class Activity:
         if self.system_comment is not None:
             body["system_comment"] = self.system_comment
         if self.to_stage is not None:
-            body["to_stage"] = self.to_stage.value
+            body["to_stage"] = self.to_stage
         if self.user_id is not None:
             body["user_id"] = self.user_id
         return body
@@ -133,25 +121,32 @@ class Activity:
             activity_type=_enum(d, "activity_type", ActivityType),
             comment=d.get("comment", None),
             creation_timestamp=d.get("creation_timestamp", None),
-            from_stage=_enum(d, "from_stage", Stage),
+            from_stage=d.get("from_stage", None),
             id=d.get("id", None),
             last_updated_timestamp=d.get("last_updated_timestamp", None),
             system_comment=d.get("system_comment", None),
-            to_stage=_enum(d, "to_stage", Stage),
+            to_stage=d.get("to_stage", None),
             user_id=d.get("user_id", None),
         )
 
 
 class ActivityAction(Enum):
-    """An action that a user (with sufficient permissions) could take on an activity. Valid values are:
-    * `APPROVE_TRANSITION_REQUEST`: Approve a transition request
+    """An action that a user (with sufficient permissions) could take on an activity or comment.
+
+    For activities, valid values are: * `APPROVE_TRANSITION_REQUEST`: Approve a transition request
 
     * `REJECT_TRANSITION_REQUEST`: Reject a transition request
 
-    * `CANCEL_TRANSITION_REQUEST`: Cancel (delete) a transition request"""
+    * `CANCEL_TRANSITION_REQUEST`: Cancel (delete) a transition request
+
+    For comments, valid values are: * `EDIT_COMMENT`: Edit the comment
+
+    * `DELETE_COMMENT`: Delete the comment"""
 
     APPROVE_TRANSITION_REQUEST = "APPROVE_TRANSITION_REQUEST"
     CANCEL_TRANSITION_REQUEST = "CANCEL_TRANSITION_REQUEST"
+    DELETE_COMMENT = "DELETE_COMMENT"
+    EDIT_COMMENT = "EDIT_COMMENT"
     REJECT_TRANSITION_REQUEST = "REJECT_TRANSITION_REQUEST"
 
 
@@ -181,13 +176,15 @@ class ActivityType(Enum):
 
 @dataclass
 class ApproveTransitionRequest:
+    """Details required to identify and approve a model version stage transition request."""
+
     name: str
     """Name of the model."""
 
     version: str
     """Version of the model."""
 
-    stage: Stage
+    stage: str
     """Target stage of the transition. Valid values are:
     
     * `None`: The initial stage of a model version.
@@ -214,7 +211,7 @@ class ApproveTransitionRequest:
         if self.name is not None:
             body["name"] = self.name
         if self.stage is not None:
-            body["stage"] = self.stage.value
+            body["stage"] = self.stage
         if self.version is not None:
             body["version"] = self.version
         return body
@@ -241,7 +238,7 @@ class ApproveTransitionRequest:
             archive_existing_versions=d.get("archive_existing_versions", None),
             comment=d.get("comment", None),
             name=d.get("name", None),
-            stage=_enum(d, "stage", Stage),
+            stage=d.get("stage", None),
             version=d.get("version", None),
         )
 
@@ -249,7 +246,7 @@ class ApproveTransitionRequest:
 @dataclass
 class ApproveTransitionRequestResponse:
     activity: Optional[Activity] = None
-    """Activity recorded for the action."""
+    """New activity generated as a result of this operation."""
 
     def as_dict(self) -> dict:
         """Serializes the ApproveTransitionRequestResponse into a dictionary suitable for use as a JSON request body."""
@@ -272,30 +269,41 @@ class ApproveTransitionRequestResponse:
 
 
 class CommentActivityAction(Enum):
-    """An action that a user (with sufficient permissions) could take on a comment. Valid values are: *
-    `EDIT_COMMENT`: Edit the comment
+    """An action that a user (with sufficient permissions) could take on an activity or comment.
+
+    For activities, valid values are: * `APPROVE_TRANSITION_REQUEST`: Approve a transition request
+
+    * `REJECT_TRANSITION_REQUEST`: Reject a transition request
+
+    * `CANCEL_TRANSITION_REQUEST`: Cancel (delete) a transition request
+
+    For comments, valid values are: * `EDIT_COMMENT`: Edit the comment
 
     * `DELETE_COMMENT`: Delete the comment"""
 
+    APPROVE_TRANSITION_REQUEST = "APPROVE_TRANSITION_REQUEST"
+    CANCEL_TRANSITION_REQUEST = "CANCEL_TRANSITION_REQUEST"
     DELETE_COMMENT = "DELETE_COMMENT"
     EDIT_COMMENT = "EDIT_COMMENT"
+    REJECT_TRANSITION_REQUEST = "REJECT_TRANSITION_REQUEST"
 
 
 @dataclass
 class CommentObject:
-    """Comment details."""
+    """For activities, this contains the activity recorded for the action. For comments, this contains
+    the comment details. For transition requests, this contains the transition request details."""
 
     available_actions: Optional[List[CommentActivityAction]] = None
     """Array of actions on the activity allowed for the current viewer."""
 
     comment: Optional[str] = None
-    """User-provided comment on the action."""
+    """User-provided comment associated with the activity, comment, or transition request."""
 
     creation_timestamp: Optional[int] = None
     """Creation time of the object, as a Unix timestamp in milliseconds."""
 
     id: Optional[str] = None
-    """Comment ID"""
+    """Unique identifier for the object."""
 
     last_updated_timestamp: Optional[int] = None
     """Time of the object at last update, as a Unix timestamp in milliseconds."""
@@ -352,6 +360,8 @@ class CommentObject:
 
 @dataclass
 class CreateComment:
+    """Details required to create a comment on a model version."""
+
     name: str
     """Name of the model."""
 
@@ -392,7 +402,7 @@ class CreateComment:
 @dataclass
 class CreateCommentResponse:
     comment: Optional[CommentObject] = None
-    """Comment details."""
+    """New comment object"""
 
     def as_dict(self) -> dict:
         """Serializes the CreateCommentResponse into a dictionary suitable for use as a JSON request body."""
@@ -935,6 +945,8 @@ class CreateModelVersionResponse:
 
 @dataclass
 class CreateRegistryWebhook:
+    """Details required to create a registry webhook."""
+
     events: List[RegistryWebhookEvent]
     """Events that can trigger a registry webhook: * `MODEL_VERSION_CREATED`: A new model version was
     created for the associated model.
@@ -969,8 +981,10 @@ class CreateRegistryWebhook:
     """User-specified description for the webhook."""
 
     http_url_spec: Optional[HttpUrlSpec] = None
+    """External HTTPS URL called on event trigger (by using a POST request)."""
 
     job_spec: Optional[JobSpec] = None
+    """ID of the job that the webhook runs."""
 
     model_name: Optional[str] = None
     """If model name is not specified, a registry-wide webhook is created that listens for the
@@ -1119,13 +1133,15 @@ class CreateRunResponse:
 
 @dataclass
 class CreateTransitionRequest:
+    """Details required to create a model version stage transition request."""
+
     name: str
     """Name of the model."""
 
     version: str
     """Version of the model."""
 
-    stage: Stage
+    stage: str
     """Target stage of the transition. Valid values are:
     
     * `None`: The initial stage of a model version.
@@ -1147,7 +1163,7 @@ class CreateTransitionRequest:
         if self.name is not None:
             body["name"] = self.name
         if self.stage is not None:
-            body["stage"] = self.stage.value
+            body["stage"] = self.stage
         if self.version is not None:
             body["version"] = self.version
         return body
@@ -1171,7 +1187,7 @@ class CreateTransitionRequest:
         return cls(
             comment=d.get("comment", None),
             name=d.get("name", None),
-            stage=_enum(d, "stage", Stage),
+            stage=d.get("stage", None),
             version=d.get("version", None),
         )
 
@@ -1179,7 +1195,7 @@ class CreateTransitionRequest:
 @dataclass
 class CreateTransitionRequestResponse:
     request: Optional[TransitionRequest] = None
-    """Transition request details."""
+    """New activity generated for stage transition request."""
 
     def as_dict(self) -> dict:
         """Serializes the CreateTransitionRequestResponse into a dictionary suitable for use as a JSON request body."""
@@ -1667,28 +1683,27 @@ class DeleteTagResponse:
 
 @dataclass
 class DeleteTransitionRequestResponse:
+    activity: Optional[Activity] = None
+    """New activity generated as a result of this operation."""
+
     def as_dict(self) -> dict:
         """Serializes the DeleteTransitionRequestResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
+        if self.activity:
+            body["activity"] = self.activity.as_dict()
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the DeleteTransitionRequestResponse into a shallow dictionary of its immediate attributes."""
         body = {}
+        if self.activity:
+            body["activity"] = self.activity
         return body
 
     @classmethod
     def from_dict(cls, d: Dict[str, Any]) -> DeleteTransitionRequestResponse:
         """Deserializes the DeleteTransitionRequestResponse from a dictionary."""
-        return cls()
-
-
-class DeleteTransitionRequestStage(Enum):
-
-    ARCHIVED = "Archived"
-    NONE = "None"
-    PRODUCTION = "Production"
-    STAGING = "Staging"
+        return cls(activity=_from_dict(d, "activity", Activity))
 
 
 @dataclass
@@ -1793,7 +1808,6 @@ class ExperimentAccessControlRequest:
     """name of the group"""
 
     permission_level: Optional[ExperimentPermissionLevel] = None
-    """Permission level"""
 
     service_principal_name: Optional[str] = None
     """application ID of a service principal"""
@@ -1904,7 +1918,6 @@ class ExperimentPermission:
     inherited_from_object: Optional[List[str]] = None
 
     permission_level: Optional[ExperimentPermissionLevel] = None
-    """Permission level"""
 
     def as_dict(self) -> dict:
         """Serializes the ExperimentPermission into a dictionary suitable for use as a JSON request body."""
@@ -1991,7 +2004,6 @@ class ExperimentPermissionsDescription:
     description: Optional[str] = None
 
     permission_level: Optional[ExperimentPermissionLevel] = None
-    """Permission level"""
 
     def as_dict(self) -> dict:
         """Serializes the ExperimentPermissionsDescription into a dictionary suitable for use as a JSON request body."""
@@ -2088,6 +2100,241 @@ class ExperimentTag:
         return cls(key=d.get("key", None), value=d.get("value", None))
 
 
+@dataclass
+class Feature:
+    """Feature for model version."""
+
+    feature_name: Optional[str] = None
+    """Feature name"""
+
+    feature_table_id: Optional[str] = None
+    """Feature table id"""
+
+    feature_table_name: Optional[str] = None
+    """Feature table name"""
+
+    def as_dict(self) -> dict:
+        """Serializes the Feature into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.feature_name is not None:
+            body["feature_name"] = self.feature_name
+        if self.feature_table_id is not None:
+            body["feature_table_id"] = self.feature_table_id
+        if self.feature_table_name is not None:
+            body["feature_table_name"] = self.feature_table_name
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Feature into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.feature_name is not None:
+            body["feature_name"] = self.feature_name
+        if self.feature_table_id is not None:
+            body["feature_table_id"] = self.feature_table_id
+        if self.feature_table_name is not None:
+            body["feature_table_name"] = self.feature_table_name
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> Feature:
+        """Deserializes the Feature from a dictionary."""
+        return cls(
+            feature_name=d.get("feature_name", None),
+            feature_table_id=d.get("feature_table_id", None),
+            feature_table_name=d.get("feature_table_name", None),
+        )
+
+
+@dataclass
+class FeatureLineage:
+    feature_specs: Optional[List[FeatureLineageFeatureSpec]] = None
+    """List of feature specs that contain this feature."""
+
+    models: Optional[List[FeatureLineageModel]] = None
+    """List of Unity Catalog models that were trained on this feature."""
+
+    online_features: Optional[List[FeatureLineageOnlineFeature]] = None
+    """List of online features that use this feature as source."""
+
+    def as_dict(self) -> dict:
+        """Serializes the FeatureLineage into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.feature_specs:
+            body["feature_specs"] = [v.as_dict() for v in self.feature_specs]
+        if self.models:
+            body["models"] = [v.as_dict() for v in self.models]
+        if self.online_features:
+            body["online_features"] = [v.as_dict() for v in self.online_features]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the FeatureLineage into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.feature_specs:
+            body["feature_specs"] = self.feature_specs
+        if self.models:
+            body["models"] = self.models
+        if self.online_features:
+            body["online_features"] = self.online_features
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> FeatureLineage:
+        """Deserializes the FeatureLineage from a dictionary."""
+        return cls(
+            feature_specs=_repeated_dict(d, "feature_specs", FeatureLineageFeatureSpec),
+            models=_repeated_dict(d, "models", FeatureLineageModel),
+            online_features=_repeated_dict(d, "online_features", FeatureLineageOnlineFeature),
+        )
+
+
+@dataclass
+class FeatureLineageFeatureSpec:
+    name: Optional[str] = None
+    """The full name of the feature spec in Unity Catalog."""
+
+    def as_dict(self) -> dict:
+        """Serializes the FeatureLineageFeatureSpec into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.name is not None:
+            body["name"] = self.name
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the FeatureLineageFeatureSpec into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.name is not None:
+            body["name"] = self.name
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> FeatureLineageFeatureSpec:
+        """Deserializes the FeatureLineageFeatureSpec from a dictionary."""
+        return cls(name=d.get("name", None))
+
+
+@dataclass
+class FeatureLineageModel:
+    name: Optional[str] = None
+    """The full name of the model in Unity Catalog."""
+
+    version: Optional[int] = None
+    """The version of the model."""
+
+    def as_dict(self) -> dict:
+        """Serializes the FeatureLineageModel into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.name is not None:
+            body["name"] = self.name
+        if self.version is not None:
+            body["version"] = self.version
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the FeatureLineageModel into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.name is not None:
+            body["name"] = self.name
+        if self.version is not None:
+            body["version"] = self.version
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> FeatureLineageModel:
+        """Deserializes the FeatureLineageModel from a dictionary."""
+        return cls(name=d.get("name", None), version=d.get("version", None))
+
+
+@dataclass
+class FeatureLineageOnlineFeature:
+    feature_name: Optional[str] = None
+    """The name of the online feature (column name)."""
+
+    table_name: Optional[str] = None
+    """The full name of the online table in Unity Catalog."""
+
+    def as_dict(self) -> dict:
+        """Serializes the FeatureLineageOnlineFeature into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.feature_name is not None:
+            body["feature_name"] = self.feature_name
+        if self.table_name is not None:
+            body["table_name"] = self.table_name
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the FeatureLineageOnlineFeature into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.feature_name is not None:
+            body["feature_name"] = self.feature_name
+        if self.table_name is not None:
+            body["table_name"] = self.table_name
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> FeatureLineageOnlineFeature:
+        """Deserializes the FeatureLineageOnlineFeature from a dictionary."""
+        return cls(feature_name=d.get("feature_name", None), table_name=d.get("table_name", None))
+
+
+@dataclass
+class FeatureList:
+    """Feature list wrap all the features for a model version"""
+
+    features: Optional[List[Feature]] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the FeatureList into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.features:
+            body["features"] = [v.as_dict() for v in self.features]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the FeatureList into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.features:
+            body["features"] = self.features
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> FeatureList:
+        """Deserializes the FeatureList from a dictionary."""
+        return cls(features=_repeated_dict(d, "features", Feature))
+
+
+@dataclass
+class FeatureTag:
+    """Represents a tag on a feature in a feature table."""
+
+    key: str
+
+    value: Optional[str] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the FeatureTag into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.key is not None:
+            body["key"] = self.key
+        if self.value is not None:
+            body["value"] = self.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the FeatureTag into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.key is not None:
+            body["key"] = self.key
+        if self.value is not None:
+            body["value"] = self.value
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> FeatureTag:
+        """Deserializes the FeatureTag from a dictionary."""
+        return cls(key=d.get("key", None), value=d.get("value", None))
+
+
 @dataclass
 class FileInfo:
     """Metadata of a single artifact file or directory."""
@@ -2735,9 +2982,8 @@ class JobSpecWithoutSecret:
     """ID of the job that the webhook runs."""
 
     workspace_url: Optional[str] = None
-    """URL of the workspace containing the job that this webhook runs. Defaults to the workspace URL in
-    which the webhook is created. If not specified, the job’s workspace is assumed to be the same
-    as the webhook’s."""
+    """URL of the workspace containing the job that this webhook runs. If not specified, the job’s
+    workspace URL is assumed to be the same as the workspace where the webhook is created."""
 
     def as_dict(self) -> dict:
         """Serializes the JobSpecWithoutSecret into a dictionary suitable for use as a JSON request body."""
@@ -2841,6 +3087,41 @@ class ListExperimentsResponse:
         )
 
 
+@dataclass
+class ListFeatureTagsResponse:
+    """Response message for ListFeatureTag."""
+
+    feature_tags: Optional[List[FeatureTag]] = None
+
+    next_page_token: Optional[str] = None
+    """Pagination token to request the next page of results for this query."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ListFeatureTagsResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.feature_tags:
+            body["feature_tags"] = [v.as_dict() for v in self.feature_tags]
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListFeatureTagsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.feature_tags:
+            body["feature_tags"] = self.feature_tags
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ListFeatureTagsResponse:
+        """Deserializes the ListFeatureTagsResponse from a dictionary."""
+        return cls(
+            feature_tags=_repeated_dict(d, "feature_tags", FeatureTag), next_page_token=d.get("next_page_token", None)
+        )
+
+
 @dataclass
 class ListModelsResponse:
     next_page_token: Optional[str] = None
@@ -2875,6 +3156,41 @@ class ListModelsResponse:
         )
 
 
+@dataclass
+class ListOnlineStoresResponse:
+    next_page_token: Optional[str] = None
+    """Pagination token to request the next page of results for this query."""
+
+    online_stores: Optional[List[OnlineStore]] = None
+    """List of online stores."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ListOnlineStoresResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        if self.online_stores:
+            body["online_stores"] = [v.as_dict() for v in self.online_stores]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListOnlineStoresResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        if self.online_stores:
+            body["online_stores"] = self.online_stores
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ListOnlineStoresResponse:
+        """Deserializes the ListOnlineStoresResponse from a dictionary."""
+        return cls(
+            next_page_token=d.get("next_page_token", None),
+            online_stores=_repeated_dict(d, "online_stores", OnlineStore),
+        )
+
+
 @dataclass
 class ListRegistryWebhooks:
     next_page_token: Optional[str] = None
@@ -3839,7 +4155,7 @@ class ModelDatabricks:
     """Unique identifier for the object."""
 
     last_updated_timestamp: Optional[int] = None
-    """Time of the object at last update, as a Unix timestamp in milliseconds."""
+    """Last update time of the object, as a Unix timestamp in milliseconds."""
 
     latest_versions: Optional[List[ModelVersion]] = None
     """Array of model versions, each the latest version for its stage."""
@@ -3848,8 +4164,7 @@ class ModelDatabricks:
     """Name of the model."""
 
     permission_level: Optional[PermissionLevel] = None
-    """Permission level of the requesting user on the object. For what is allowed at each level, see
-    [MLflow Model permissions](..)."""
+    """Permission level granted for the requesting user on this registered model"""
 
     tags: Optional[List[ModelTag]] = None
     """Array of tags associated with the model."""
@@ -3982,6 +4297,8 @@ class ModelOutput:
 
 @dataclass
 class ModelTag:
+    """Tag for a registered model"""
+
     key: Optional[str] = None
     """The tag key."""
 
@@ -4141,29 +4458,29 @@ class ModelVersionDatabricks:
     creation_timestamp: Optional[int] = None
     """Creation time of the object, as a Unix timestamp in milliseconds."""
 
-    current_stage: Optional[Stage] = None
-    """Stage of the model version. Valid values are:
-    
-    * `None`: The initial stage of a model version.
-    
-    * `Staging`: Staging or pre-production stage.
-    
-    * `Production`: Production stage.
-    
-    * `Archived`: Archived stage."""
+    current_stage: Optional[str] = None
 
     description: Optional[str] = None
     """User-specified description for the object."""
 
+    email_subscription_status: Optional[RegistryEmailSubscriptionType] = None
+    """Email Subscription Status: This is the subscription status of the user to the model version
+    Users get subscribed by interacting with the model version."""
+
+    feature_list: Optional[FeatureList] = None
+    """Feature lineage of `model_version`."""
+
     last_updated_timestamp: Optional[int] = None
     """Time of the object at last update, as a Unix timestamp in milliseconds."""
 
     name: Optional[str] = None
     """Name of the model."""
 
+    open_requests: Optional[List[Activity]] = None
+    """Open requests for this `model_versions`. Gap in sequence number is intentional and is done in
+    order to match field sequence numbers of `ModelVersion` proto message"""
+
     permission_level: Optional[PermissionLevel] = None
-    """Permission level of the requesting user on the object. For what is allowed at each level, see
-    [MLflow Model permissions](..)."""
 
     run_id: Optional[str] = None
     """Unique identifier for the MLflow tracking run associated with the source model artifacts."""
@@ -4178,12 +4495,6 @@ class ModelVersionDatabricks:
     model version."""
 
     status: Optional[Status] = None
-    """The status of the model version. Valid values are: * `PENDING_REGISTRATION`: Request to register
-    a new model version is pending as server performs background tasks.
-    
-    * `FAILED_REGISTRATION`: Request to register a new model version has failed.
-    
-    * `READY`: Model version is ready for use."""
 
     status_message: Optional[str] = None
     """Details on the current status, for example why registration failed."""
@@ -4203,13 +4514,19 @@ class ModelVersionDatabricks:
         if self.creation_timestamp is not None:
             body["creation_timestamp"] = self.creation_timestamp
         if self.current_stage is not None:
-            body["current_stage"] = self.current_stage.value
+            body["current_stage"] = self.current_stage
         if self.description is not None:
             body["description"] = self.description
+        if self.email_subscription_status is not None:
+            body["email_subscription_status"] = self.email_subscription_status.value
+        if self.feature_list:
+            body["feature_list"] = self.feature_list.as_dict()
         if self.last_updated_timestamp is not None:
             body["last_updated_timestamp"] = self.last_updated_timestamp
         if self.name is not None:
             body["name"] = self.name
+        if self.open_requests:
+            body["open_requests"] = [v.as_dict() for v in self.open_requests]
         if self.permission_level is not None:
             body["permission_level"] = self.permission_level.value
         if self.run_id is not None:
@@ -4239,10 +4556,16 @@ class ModelVersionDatabricks:
             body["current_stage"] = self.current_stage
         if self.description is not None:
             body["description"] = self.description
+        if self.email_subscription_status is not None:
+            body["email_subscription_status"] = self.email_subscription_status
+        if self.feature_list:
+            body["feature_list"] = self.feature_list
         if self.last_updated_timestamp is not None:
             body["last_updated_timestamp"] = self.last_updated_timestamp
         if self.name is not None:
             body["name"] = self.name
+        if self.open_requests:
+            body["open_requests"] = self.open_requests
         if self.permission_level is not None:
             body["permission_level"] = self.permission_level
         if self.run_id is not None:
@@ -4268,10 +4591,13 @@ class ModelVersionDatabricks:
         """Deserializes the ModelVersionDatabricks from a dictionary."""
         return cls(
             creation_timestamp=d.get("creation_timestamp", None),
-            current_stage=_enum(d, "current_stage", Stage),
+            current_stage=d.get("current_stage", None),
             description=d.get("description", None),
+            email_subscription_status=_enum(d, "email_subscription_status", RegistryEmailSubscriptionType),
+            feature_list=_from_dict(d, "feature_list", FeatureList),
             last_updated_timestamp=d.get("last_updated_timestamp", None),
             name=d.get("name", None),
+            open_requests=_repeated_dict(d, "open_requests", Activity),
             permission_level=_enum(d, "permission_level", PermissionLevel),
             run_id=d.get("run_id", None),
             run_link=d.get("run_link", None),
@@ -4285,7 +4611,12 @@ class ModelVersionDatabricks:
 
 
 class ModelVersionStatus(Enum):
-    """Current status of `model_version`"""
+    """The status of the model version. Valid values are: * `PENDING_REGISTRATION`: Request to register
+    a new model version is pending as server performs background tasks.
+
+    * `FAILED_REGISTRATION`: Request to register a new model version has failed.
+
+    * `READY`: Model version is ready for use."""
 
     FAILED_REGISTRATION = "FAILED_REGISTRATION"
     PENDING_REGISTRATION = "PENDING_REGISTRATION"
@@ -4324,6 +4655,77 @@ class ModelVersionTag:
         return cls(key=d.get("key", None), value=d.get("value", None))
 
 
+@dataclass
+class OnlineStore:
+    """An OnlineStore is a logical database instance that stores and serves features online."""
+
+    name: str
+    """The name of the online store. This is the unique identifier for the online store."""
+
+    capacity: str
+    """The capacity of the online store. Valid values are "CU_1", "CU_2", "CU_4", "CU_8"."""
+
+    creation_time: Optional[str] = None
+    """The timestamp when the online store was created."""
+
+    creator: Optional[str] = None
+    """The email of the creator of the online store."""
+
+    state: Optional[OnlineStoreState] = None
+    """The current state of the online store."""
+
+    def as_dict(self) -> dict:
+        """Serializes the OnlineStore into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.capacity is not None:
+            body["capacity"] = self.capacity
+        if self.creation_time is not None:
+            body["creation_time"] = self.creation_time
+        if self.creator is not None:
+            body["creator"] = self.creator
+        if self.name is not None:
+            body["name"] = self.name
+        if self.state is not None:
+            body["state"] = self.state.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the OnlineStore into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.capacity is not None:
+            body["capacity"] = self.capacity
+        if self.creation_time is not None:
+            body["creation_time"] = self.creation_time
+        if self.creator is not None:
+            body["creator"] = self.creator
+        if self.name is not None:
+            body["name"] = self.name
+        if self.state is not None:
+            body["state"] = self.state
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> OnlineStore:
+        """Deserializes the OnlineStore from a dictionary."""
+        return cls(
+            capacity=d.get("capacity", None),
+            creation_time=d.get("creation_time", None),
+            creator=d.get("creator", None),
+            name=d.get("name", None),
+            state=_enum(d, "state", OnlineStoreState),
+        )
+
+
+class OnlineStoreState(Enum):
+
+    AVAILABLE = "AVAILABLE"
+    DELETING = "DELETING"
+    FAILING_OVER = "FAILING_OVER"
+    STARTING = "STARTING"
+    STOPPED = "STOPPED"
+    UPDATING = "UPDATING"
+
+
 @dataclass
 class Param:
     """Param associated with a run."""
@@ -4362,6 +4764,7 @@ class PermissionLevel(Enum):
     """Permission level of the requesting user on the object. For what is allowed at each level, see
     [MLflow Model permissions](..)."""
 
+    CAN_CREATE_REGISTERED_MODEL = "CAN_CREATE_REGISTERED_MODEL"
     CAN_EDIT = "CAN_EDIT"
     CAN_MANAGE = "CAN_MANAGE"
     CAN_MANAGE_PRODUCTION_VERSIONS = "CAN_MANAGE_PRODUCTION_VERSIONS"
@@ -4369,13 +4772,129 @@ class PermissionLevel(Enum):
     CAN_READ = "CAN_READ"
 
 
+@dataclass
+class PublishSpec:
+    online_store: str
+    """The name of the target online store."""
+
+    online_table_name: str
+    """The full three-part (catalog, schema, table) name of the online table."""
+
+    publish_mode: Optional[PublishSpecPublishMode] = None
+    """The publish mode of the pipeline that syncs the online table with the source table. Defaults to
+    TRIGGERED if not specified. All publish modes require the source table to have Change Data Feed
+    (CDF) enabled."""
+
+    def as_dict(self) -> dict:
+        """Serializes the PublishSpec into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.online_store is not None:
+            body["online_store"] = self.online_store
+        if self.online_table_name is not None:
+            body["online_table_name"] = self.online_table_name
+        if self.publish_mode is not None:
+            body["publish_mode"] = self.publish_mode.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PublishSpec into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.online_store is not None:
+            body["online_store"] = self.online_store
+        if self.online_table_name is not None:
+            body["online_table_name"] = self.online_table_name
+        if self.publish_mode is not None:
+            body["publish_mode"] = self.publish_mode
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> PublishSpec:
+        """Deserializes the PublishSpec from a dictionary."""
+        return cls(
+            online_store=d.get("online_store", None),
+            online_table_name=d.get("online_table_name", None),
+            publish_mode=_enum(d, "publish_mode", PublishSpecPublishMode),
+        )
+
+
+class PublishSpecPublishMode(Enum):
+
+    CONTINUOUS = "CONTINUOUS"
+    TRIGGERED = "TRIGGERED"
+
+
+@dataclass
+class PublishTableRequest:
+    publish_spec: PublishSpec
+    """The specification for publishing the online table from the source table."""
+
+    source_table_name: Optional[str] = None
+    """The full three-part (catalog, schema, table) name of the source table."""
+
+    def as_dict(self) -> dict:
+        """Serializes the PublishTableRequest into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.publish_spec:
+            body["publish_spec"] = self.publish_spec.as_dict()
+        if self.source_table_name is not None:
+            body["source_table_name"] = self.source_table_name
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PublishTableRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.publish_spec:
+            body["publish_spec"] = self.publish_spec
+        if self.source_table_name is not None:
+            body["source_table_name"] = self.source_table_name
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> PublishTableRequest:
+        """Deserializes the PublishTableRequest from a dictionary."""
+        return cls(
+            publish_spec=_from_dict(d, "publish_spec", PublishSpec), source_table_name=d.get("source_table_name", None)
+        )
+
+
+@dataclass
+class PublishTableResponse:
+    online_table_name: Optional[str] = None
+    """The full three-part (catalog, schema, table) name of the online table."""
+
+    pipeline_id: Optional[str] = None
+    """The ID of the pipeline that syncs the online table with the source table."""
+
+    def as_dict(self) -> dict:
+        """Serializes the PublishTableResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.online_table_name is not None:
+            body["online_table_name"] = self.online_table_name
+        if self.pipeline_id is not None:
+            body["pipeline_id"] = self.pipeline_id
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PublishTableResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.online_table_name is not None:
+            body["online_table_name"] = self.online_table_name
+        if self.pipeline_id is not None:
+            body["pipeline_id"] = self.pipeline_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> PublishTableResponse:
+        """Deserializes the PublishTableResponse from a dictionary."""
+        return cls(online_table_name=d.get("online_table_name", None), pipeline_id=d.get("pipeline_id", None))
+
+
 @dataclass
 class RegisteredModelAccessControlRequest:
     group_name: Optional[str] = None
     """name of the group"""
 
     permission_level: Optional[RegisteredModelPermissionLevel] = None
-    """Permission level"""
 
     service_principal_name: Optional[str] = None
     """application ID of a service principal"""
@@ -4486,7 +5005,6 @@ class RegisteredModelPermission:
     inherited_from_object: Optional[List[str]] = None
 
     permission_level: Optional[RegisteredModelPermissionLevel] = None
-    """Permission level"""
 
     def as_dict(self) -> dict:
         """Serializes the RegisteredModelPermission into a dictionary suitable for use as a JSON request body."""
@@ -4575,7 +5093,6 @@ class RegisteredModelPermissionsDescription:
     description: Optional[str] = None
 
     permission_level: Optional[RegisteredModelPermissionLevel] = None
-    """Permission level"""
 
     def as_dict(self) -> dict:
         """Serializes the RegisteredModelPermissionsDescription into a dictionary suitable for use as a JSON request body."""
@@ -4638,6 +5155,18 @@ class RegisteredModelPermissionsRequest:
         )
 
 
+class RegistryEmailSubscriptionType(Enum):
+    """.. note:: Experimental: This entity may change or be removed in a future release without
+    warning. Email subscription types for registry notifications: - `ALL_EVENTS`: Subscribed to all
+    events. - `DEFAULT`: Default subscription type. - `SUBSCRIBED`: Subscribed to notifications. -
+    `UNSUBSCRIBED`: Not subscribed to notifications."""
+
+    ALL_EVENTS = "ALL_EVENTS"
+    DEFAULT = "DEFAULT"
+    SUBSCRIBED = "SUBSCRIBED"
+    UNSUBSCRIBED = "UNSUBSCRIBED"
+
+
 @dataclass
 class RegistryWebhook:
     creation_timestamp: Optional[int] = None
@@ -4690,13 +5219,6 @@ class RegistryWebhook:
     """Name of the model whose events would trigger this webhook."""
 
     status: Optional[RegistryWebhookStatus] = None
-    """Enable or disable triggering the webhook, or put the webhook into test mode. The default is
-    `ACTIVE`: * `ACTIVE`: Webhook is triggered when an associated event happens.
-    
-    * `DISABLED`: Webhook is not triggered.
-    
-    * `TEST_MODE`: Webhook can be triggered through the test endpoint, but is not triggered on a
-    real event."""
 
     def as_dict(self) -> dict:
         """Serializes the RegistryWebhook into a dictionary suitable for use as a JSON request body."""
@@ -4792,13 +5314,15 @@ class RegistryWebhookStatus(Enum):
 
 @dataclass
 class RejectTransitionRequest:
+    """Details required to identify and reject a model version stage transition request."""
+
     name: str
     """Name of the model."""
 
     version: str
     """Version of the model."""
 
-    stage: Stage
+    stage: str
     """Target stage of the transition. Valid values are:
     
     * `None`: The initial stage of a model version.
@@ -4820,7 +5344,7 @@ class RejectTransitionRequest:
         if self.name is not None:
             body["name"] = self.name
         if self.stage is not None:
-            body["stage"] = self.stage.value
+            body["stage"] = self.stage
         if self.version is not None:
             body["version"] = self.version
         return body
@@ -4844,7 +5368,7 @@ class RejectTransitionRequest:
         return cls(
             comment=d.get("comment", None),
             name=d.get("name", None),
-            stage=_enum(d, "stage", Stage),
+            stage=d.get("stage", None),
             version=d.get("version", None),
         )
 
@@ -4852,7 +5376,7 @@ class RejectTransitionRequest:
 @dataclass
 class RejectTransitionRequestResponse:
     activity: Optional[Activity] = None
-    """Activity recorded for the action."""
+    """New activity generated as a result of this operation."""
 
     def as_dict(self) -> dict:
         """Serializes the RejectTransitionRequestResponse into a dictionary suitable for use as a JSON request body."""
@@ -6140,23 +6664,6 @@ class SetTagResponse:
         return cls()
 
 
-class Stage(Enum):
-    """Stage of the model version. Valid values are:
-
-    * `None`: The initial stage of a model version.
-
-    * `Staging`: Staging or pre-production stage.
-
-    * `Production`: Production stage.
-
-    * `Archived`: Archived stage."""
-
-    ARCHIVED = "Archived"
-    NONE = "None"
-    PRODUCTION = "Production"
-    STAGING = "Staging"
-
-
 class Status(Enum):
     """The status of the model version. Valid values are: * `PENDING_REGISTRATION`: Request to register
     a new model version is pending as server performs background tasks.
@@ -6170,42 +6677,10 @@ class Status(Enum):
     READY = "READY"
 
 
-@dataclass
-class TestRegistryWebhook:
-    """Test webhook response object."""
-
-    body: Optional[str] = None
-    """Body of the response from the webhook URL"""
-
-    status_code: Optional[int] = None
-    """Status code returned by the webhook URL"""
-
-    def as_dict(self) -> dict:
-        """Serializes the TestRegistryWebhook into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.body is not None:
-            body["body"] = self.body
-        if self.status_code is not None:
-            body["status_code"] = self.status_code
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the TestRegistryWebhook into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.body is not None:
-            body["body"] = self.body
-        if self.status_code is not None:
-            body["status_code"] = self.status_code
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> TestRegistryWebhook:
-        """Deserializes the TestRegistryWebhook from a dictionary."""
-        return cls(body=d.get("body", None), status_code=d.get("status_code", None))
-
-
 @dataclass
 class TestRegistryWebhookRequest:
+    """Details required to test a registry webhook."""
+
     id: str
     """Webhook ID"""
 
@@ -6239,38 +6714,47 @@ class TestRegistryWebhookRequest:
 
 @dataclass
 class TestRegistryWebhookResponse:
-    webhook: Optional[TestRegistryWebhook] = None
-    """Test webhook response object."""
+    body: Optional[str] = None
+    """Body of the response from the webhook URL"""
+
+    status_code: Optional[int] = None
+    """Status code returned by the webhook URL"""
 
     def as_dict(self) -> dict:
         """Serializes the TestRegistryWebhookResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.webhook:
-            body["webhook"] = self.webhook.as_dict()
+        if self.body is not None:
+            body["body"] = self.body
+        if self.status_code is not None:
+            body["status_code"] = self.status_code
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the TestRegistryWebhookResponse into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.webhook:
-            body["webhook"] = self.webhook
+        if self.body is not None:
+            body["body"] = self.body
+        if self.status_code is not None:
+            body["status_code"] = self.status_code
         return body
 
     @classmethod
     def from_dict(cls, d: Dict[str, Any]) -> TestRegistryWebhookResponse:
         """Deserializes the TestRegistryWebhookResponse from a dictionary."""
-        return cls(webhook=_from_dict(d, "webhook", TestRegistryWebhook))
+        return cls(body=d.get("body", None), status_code=d.get("status_code", None))
 
 
 @dataclass
 class TransitionModelVersionStageDatabricks:
+    """Details required to transition a model version's stage."""
+
     name: str
     """Name of the model."""
 
     version: str
     """Version of the model."""
 
-    stage: Stage
+    stage: str
     """Target stage of the transition. Valid values are:
     
     * `None`: The initial stage of a model version.
@@ -6297,7 +6781,7 @@ class TransitionModelVersionStageDatabricks:
         if self.name is not None:
             body["name"] = self.name
         if self.stage is not None:
-            body["stage"] = self.stage.value
+            body["stage"] = self.stage
         if self.version is not None:
             body["version"] = self.version
         return body
@@ -6324,25 +6808,26 @@ class TransitionModelVersionStageDatabricks:
             archive_existing_versions=d.get("archive_existing_versions", None),
             comment=d.get("comment", None),
             name=d.get("name", None),
-            stage=_enum(d, "stage", Stage),
+            stage=d.get("stage", None),
             version=d.get("version", None),
         )
 
 
 @dataclass
 class TransitionRequest:
-    """Transition request details."""
+    """For activities, this contains the activity recorded for the action. For comments, this contains
+    the comment details. For transition requests, this contains the transition request details."""
 
     available_actions: Optional[List[ActivityAction]] = None
     """Array of actions on the activity allowed for the current viewer."""
 
     comment: Optional[str] = None
-    """User-provided comment associated with the transition request."""
+    """User-provided comment associated with the activity, comment, or transition request."""
 
     creation_timestamp: Optional[int] = None
     """Creation time of the object, as a Unix timestamp in milliseconds."""
 
-    to_stage: Optional[Stage] = None
+    to_stage: Optional[str] = None
     """Target stage of the transition (if the activity is stage transition related). Valid values are:
     
     * `None`: The initial stage of a model version.
@@ -6366,7 +6851,7 @@ class TransitionRequest:
         if self.creation_timestamp is not None:
             body["creation_timestamp"] = self.creation_timestamp
         if self.to_stage is not None:
-            body["to_stage"] = self.to_stage.value
+            body["to_stage"] = self.to_stage
         if self.user_id is not None:
             body["user_id"] = self.user_id
         return body
@@ -6393,37 +6878,40 @@ class TransitionRequest:
             available_actions=_repeated_enum(d, "available_actions", ActivityAction),
             comment=d.get("comment", None),
             creation_timestamp=d.get("creation_timestamp", None),
-            to_stage=_enum(d, "to_stage", Stage),
+            to_stage=d.get("to_stage", None),
             user_id=d.get("user_id", None),
         )
 
 
 @dataclass
 class TransitionStageResponse:
-    model_version: Optional[ModelVersionDatabricks] = None
+    model_version_databricks: Optional[ModelVersionDatabricks] = None
+    """Updated model version"""
 
     def as_dict(self) -> dict:
         """Serializes the TransitionStageResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.model_version:
-            body["model_version"] = self.model_version.as_dict()
+        if self.model_version_databricks:
+            body["model_version_databricks"] = self.model_version_databricks.as_dict()
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the TransitionStageResponse into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.model_version:
-            body["model_version"] = self.model_version
+        if self.model_version_databricks:
+            body["model_version_databricks"] = self.model_version_databricks
         return body
 
     @classmethod
     def from_dict(cls, d: Dict[str, Any]) -> TransitionStageResponse:
         """Deserializes the TransitionStageResponse from a dictionary."""
-        return cls(model_version=_from_dict(d, "model_version", ModelVersionDatabricks))
+        return cls(model_version_databricks=_from_dict(d, "model_version_databricks", ModelVersionDatabricks))
 
 
 @dataclass
 class UpdateComment:
+    """Details required to edit a comment on a model version."""
+
     id: str
     """Unique identifier of an activity"""
 
@@ -6457,7 +6945,7 @@ class UpdateComment:
 @dataclass
 class UpdateCommentResponse:
     comment: Optional[CommentObject] = None
-    """Comment details."""
+    """Updated comment object"""
 
     def as_dict(self) -> dict:
         """Serializes the UpdateCommentResponse into a dictionary suitable for use as a JSON request body."""
@@ -6563,20 +7051,26 @@ class UpdateModelRequest:
 
 @dataclass
 class UpdateModelResponse:
+    registered_model: Optional[Model] = None
+
     def as_dict(self) -> dict:
         """Serializes the UpdateModelResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
+        if self.registered_model:
+            body["registered_model"] = self.registered_model.as_dict()
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the UpdateModelResponse into a shallow dictionary of its immediate attributes."""
         body = {}
+        if self.registered_model:
+            body["registered_model"] = self.registered_model
         return body
 
     @classmethod
     def from_dict(cls, d: Dict[str, Any]) -> UpdateModelResponse:
         """Deserializes the UpdateModelResponse from a dictionary."""
-        return cls()
+        return cls(registered_model=_from_dict(d, "registered_model", Model))
 
 
 @dataclass
@@ -6620,24 +7114,34 @@ class UpdateModelVersionRequest:
 
 @dataclass
 class UpdateModelVersionResponse:
+    model_version: Optional[ModelVersion] = None
+    """Return new version number generated for this model in registry."""
+
     def as_dict(self) -> dict:
         """Serializes the UpdateModelVersionResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
+        if self.model_version:
+            body["model_version"] = self.model_version.as_dict()
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the UpdateModelVersionResponse into a shallow dictionary of its immediate attributes."""
         body = {}
+        if self.model_version:
+            body["model_version"] = self.model_version
         return body
 
     @classmethod
     def from_dict(cls, d: Dict[str, Any]) -> UpdateModelVersionResponse:
         """Deserializes the UpdateModelVersionResponse from a dictionary."""
-        return cls()
+        return cls(model_version=_from_dict(d, "model_version", ModelVersion))
 
 
 @dataclass
 class UpdateRegistryWebhook:
+    """Details required to update a registry webhook. Only the fields that need to be updated should be
+    specified, and both `http_url_spec` and `job_spec` should not be specified in the same request."""
+
     id: str
     """Webhook ID"""
 
@@ -6679,13 +7183,6 @@ class UpdateRegistryWebhook:
     job_spec: Optional[JobSpec] = None
 
     status: Optional[RegistryWebhookStatus] = None
-    """Enable or disable triggering the webhook, or put the webhook into test mode. The default is
-    `ACTIVE`: * `ACTIVE`: Webhook is triggered when an associated event happens.
-    
-    * `DISABLED`: Webhook is not triggered.
-    
-    * `TEST_MODE`: Webhook can be triggered through the test endpoint, but is not triggered on a
-    real event."""
 
     def as_dict(self) -> dict:
         """Serializes the UpdateRegistryWebhook into a dictionary suitable for use as a JSON request body."""
@@ -6831,20 +7328,26 @@ class UpdateRunStatus(Enum):
 
 @dataclass
 class UpdateWebhookResponse:
+    webhook: Optional[RegistryWebhook] = None
+
     def as_dict(self) -> dict:
         """Serializes the UpdateWebhookResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
+        if self.webhook:
+            body["webhook"] = self.webhook.as_dict()
         return body
 
     def as_shallow_dict(self) -> dict:
         """Serializes the UpdateWebhookResponse into a shallow dictionary of its immediate attributes."""
         body = {}
+        if self.webhook:
+            body["webhook"] = self.webhook
         return body
 
     @classmethod
     def from_dict(cls, d: Dict[str, Any]) -> UpdateWebhookResponse:
         """Deserializes the UpdateWebhookResponse from a dictionary."""
-        return cls()
+        return cls(webhook=_from_dict(d, "webhook", RegistryWebhook))
 
 
 class ViewType(Enum):
@@ -6869,9 +7372,7 @@ class ExperimentsAPI:
     def create_experiment(
         self, name: str, *, artifact_location: Optional[str] = None, tags: Optional[List[ExperimentTag]] = None
     ) -> CreateExperimentResponse:
-        """Create experiment.
-
-        Creates an experiment with a name. Returns the ID of the newly created experiment. Validates that
+        """Creates an experiment with a name. Returns the ID of the newly created experiment. Validates that
         another experiment with the same name does not already exist and fails if another experiment with the
         same name already exists.
 
@@ -6962,9 +7463,7 @@ class ExperimentsAPI:
         tags: Optional[List[RunTag]] = None,
         user_id: Optional[str] = None,
     ) -> CreateRunResponse:
-        """Create a run.
-
-        Creates a new run within an experiment. A run is usually a single execution of a machine learning or
+        """Creates a new run within an experiment. A run is usually a single execution of a machine learning or
         data ETL pipeline. MLflow uses runs to track the `mlflowParam`, `mlflowMetric`, and `mlflowRunTag`
         associated with a single execution.
 
@@ -7002,9 +7501,7 @@ class ExperimentsAPI:
         return CreateRunResponse.from_dict(res)
 
     def delete_experiment(self, experiment_id: str):
-        """Delete an experiment.
-
-        Marks an experiment and associated metadata, runs, metrics, params, and tags for deletion. If the
+        """Marks an experiment and associated metadata, runs, metrics, params, and tags for deletion. If the
         experiment uses FileStore, artifacts associated with the experiment are also deleted.
 
         :param experiment_id: str
@@ -7055,9 +7552,7 @@ class ExperimentsAPI:
         self._api.do("DELETE", f"/api/2.0/mlflow/logged-models/{model_id}/tags/{tag_key}", headers=headers)
 
     def delete_run(self, run_id: str):
-        """Delete a run.
-
-        Marks a run for deletion.
+        """Marks a run for deletion.
 
         :param run_id: str
           ID of the run to delete.
@@ -7077,9 +7572,7 @@ class ExperimentsAPI:
     def delete_runs(
         self, experiment_id: str, max_timestamp_millis: int, *, max_runs: Optional[int] = None
     ) -> DeleteRunsResponse:
-        """Delete runs by creation time.
-
-        Bulk delete runs in an experiment that were created prior to or at the specified timestamp. Deletes at
+        """Bulk delete runs in an experiment that were created prior to or at the specified timestamp. Deletes at
         most max_runs per request. To call this API from a Databricks Notebook in Python, you can use the
         client code snippet on
 
@@ -7110,9 +7603,7 @@ class ExperimentsAPI:
         return DeleteRunsResponse.from_dict(res)
 
     def delete_tag(self, run_id: str, key: str):
-        """Delete a tag on a run.
-
-        Deletes a tag on a run. Tags are run metadata that can be updated during a run and after a run
+        """Deletes a tag on a run. Tags are run metadata that can be updated during a run and after a run
         completes.
 
         :param run_id: str
@@ -7157,9 +7648,7 @@ class ExperimentsAPI:
         return FinalizeLoggedModelResponse.from_dict(res)
 
     def get_by_name(self, experiment_name: str) -> GetExperimentByNameResponse:
-        """Get an experiment by name.
-
-        Gets metadata for an experiment.
+        """Gets metadata for an experiment.
 
         This endpoint will return deleted experiments, but prefers the active experiment if an active and
         deleted experiment share the same name. If multiple deleted experiments share the same name, the API
@@ -7184,9 +7673,7 @@ class ExperimentsAPI:
         return GetExperimentByNameResponse.from_dict(res)
 
     def get_experiment(self, experiment_id: str) -> GetExperimentResponse:
-        """Get an experiment.
-
-        Gets metadata for an experiment. This method works on deleted experiments.
+        """Gets metadata for an experiment. This method works on deleted experiments.
 
         :param experiment_id: str
           ID of the associated experiment.
@@ -7213,9 +7700,7 @@ class ExperimentsAPI:
         run_id: Optional[str] = None,
         run_uuid: Optional[str] = None,
     ) -> Iterator[Metric]:
-        """Get metric history for a run.
-
-        Gets a list of all values for the specified metric for a given run.
+        """Gets a list of all values for the specified metric for a given run.
 
         :param metric_key: str
           Name of the metric.
@@ -7274,9 +7759,7 @@ class ExperimentsAPI:
         return GetLoggedModelResponse.from_dict(res)
 
     def get_permission_levels(self, experiment_id: str) -> GetExperimentPermissionLevelsResponse:
-        """Get experiment permission levels.
-
-        Gets the permission levels that a user can have on an object.
+        """Gets the permission levels that a user can have on an object.
 
         :param experiment_id: str
           The experiment for which to get or manage permissions.
@@ -7292,9 +7775,7 @@ class ExperimentsAPI:
         return GetExperimentPermissionLevelsResponse.from_dict(res)
 
     def get_permissions(self, experiment_id: str) -> ExperimentPermissions:
-        """Get experiment permissions.
-
-        Gets the permissions of an experiment. Experiments can inherit permissions from their root object.
+        """Gets the permissions of an experiment. Experiments can inherit permissions from their root object.
 
         :param experiment_id: str
           The experiment for which to get or manage permissions.
@@ -7310,9 +7791,7 @@ class ExperimentsAPI:
         return ExperimentPermissions.from_dict(res)
 
     def get_run(self, run_id: str, *, run_uuid: Optional[str] = None) -> GetRunResponse:
-        """Get a run.
-
-        Gets the metadata, metrics, params, and tags for a run. In the case where multiple metrics with the
+        """Gets the metadata, metrics, params, and tags for a run. In the case where multiple metrics with the
         same key are logged for a run, return only the value with the latest timestamp.
 
         If there are multiple values with the latest timestamp, return the maximum of these values.
@@ -7346,9 +7825,7 @@ class ExperimentsAPI:
         run_id: Optional[str] = None,
         run_uuid: Optional[str] = None,
     ) -> Iterator[FileInfo]:
-        """List artifacts.
-
-        List artifacts for a run. Takes an optional `artifact_path` prefix which if specified, the response
+        """List artifacts for a run. Takes an optional `artifact_path` prefix which if specified, the response
         contains only artifacts with the specified prefix. A maximum of 1000 artifacts will be retrieved for
         UC Volumes. Please call `/api/2.0/fs/directories{directory_path}` for listing artifacts in UC Volumes,
         which supports pagination. See [List directory contents | Files
@@ -7400,9 +7877,7 @@ class ExperimentsAPI:
         page_token: Optional[str] = None,
         view_type: Optional[ViewType] = None,
     ) -> Iterator[Experiment]:
-        """List experiments.
-
-        Gets a list of all experiments.
+        """Gets a list of all experiments.
 
         :param max_results: int (optional)
           Maximum number of experiments desired. If `max_results` is unspecified, return all experiments. If
@@ -7444,9 +7919,7 @@ class ExperimentsAPI:
         run_id: Optional[str] = None,
         tags: Optional[List[RunTag]] = None,
     ):
-        """Log a batch of metrics/params/tags for a run.
-
-        Logs a batch of metrics, params, and tags for a run. If any data failed to be persisted, the server
+        """Logs a batch of metrics, params, and tags for a run. If any data failed to be persisted, the server
         will respond with an error (non-200 status code).
 
         In case of error (due to internal server error or an invalid request), partial data may be written.
@@ -7520,11 +7993,7 @@ class ExperimentsAPI:
     def log_inputs(
         self, run_id: str, *, datasets: Optional[List[DatasetInput]] = None, models: Optional[List[ModelInput]] = None
     ):
-        """Log inputs to a run.
-
-        **NOTE:** Experimental: This API may change or be removed in a future release without warning.
-
-        Logs inputs, such as datasets and models, to an MLflow Run.
+        """Logs inputs, such as datasets and models, to an MLflow Run.
 
         :param run_id: str
           ID of the run to log under
@@ -7550,9 +8019,7 @@ class ExperimentsAPI:
         self._api.do("POST", "/api/2.0/mlflow/runs/log-inputs", body=body, headers=headers)
 
     def log_logged_model_params(self, model_id: str, *, params: Optional[List[LoggedModelParameter]] = None):
-        """Log params for a logged model.
-
-        Logs params for a logged model. A param is a key-value pair (string key, string value). Examples
+        """Logs params for a logged model. A param is a key-value pair (string key, string value). Examples
         include hyperparameters used for ML model training. A param can be logged only once for a logged
         model, and attempting to overwrite an existing param with a different value will result in an error
 
@@ -7586,9 +8053,7 @@ class ExperimentsAPI:
         run_uuid: Optional[str] = None,
         step: Optional[int] = None,
     ):
-        """Log a metric for a run.
-
-        Log a metric for a run. A metric is a key-value pair (string key, float value) with an associated
+        """Log a metric for a run. A metric is a key-value pair (string key, float value) with an associated
         timestamp. Examples include the various metrics that represent ML model accuracy. A metric can be
         logged multiple times.
 
@@ -7643,9 +8108,10 @@ class ExperimentsAPI:
         self._api.do("POST", "/api/2.0/mlflow/runs/log-metric", body=body, headers=headers)
 
     def log_model(self, *, model_json: Optional[str] = None, run_id: Optional[str] = None):
-        """Log a model.
+        """**Note:** the [Create a logged model](/api/workspace/experiments/createloggedmodel) API replaces this
+        endpoint.
 
-        **NOTE:** Experimental: This API may change or be removed in a future release without warning.
+        Log a model to an MLflow Run.
 
         :param model_json: str (optional)
           MLmodel file in json format.
@@ -7667,11 +8133,7 @@ class ExperimentsAPI:
         self._api.do("POST", "/api/2.0/mlflow/runs/log-model", body=body, headers=headers)
 
     def log_outputs(self, run_id: str, *, models: Optional[List[ModelOutput]] = None):
-        """Log outputs from a run.
-
-        **NOTE**: Experimental: This API may change or be removed in a future release without warning.
-
-        Logs outputs, such as models, from an MLflow Run.
+        """Logs outputs, such as models, from an MLflow Run.
 
         :param run_id: str
           The ID of the Run from which to log outputs.
@@ -7693,9 +8155,7 @@ class ExperimentsAPI:
         self._api.do("POST", "/api/2.0/mlflow/runs/outputs", body=body, headers=headers)
 
     def log_param(self, key: str, value: str, *, run_id: Optional[str] = None, run_uuid: Optional[str] = None):
-        """Log a param for a run.
-
-        Logs a param used for a run. A param is a key-value pair (string key, string value). Examples include
+        """Logs a param used for a run. A param is a key-value pair (string key, string value). Examples include
         hyperparameters used for ML model training and constant dates and values used in an ETL pipeline. A
         param can be logged only once for a run.
 
@@ -7728,9 +8188,7 @@ class ExperimentsAPI:
         self._api.do("POST", "/api/2.0/mlflow/runs/log-parameter", body=body, headers=headers)
 
     def restore_experiment(self, experiment_id: str):
-        """Restore an experiment.
-
-        Restore an experiment marked for deletion. This also restores associated metadata, runs, metrics,
+        """Restore an experiment marked for deletion. This also restores associated metadata, runs, metrics,
         params, and tags. If experiment uses FileStore, underlying artifacts associated with experiment are
         also restored.
 
@@ -7752,9 +8210,7 @@ class ExperimentsAPI:
         self._api.do("POST", "/api/2.0/mlflow/experiments/restore", body=body, headers=headers)
 
     def restore_run(self, run_id: str):
-        """Restore a run.
-
-        Restores a deleted run. This also restores associated metadata, runs, metrics, params, and tags.
+        """Restores a deleted run. This also restores associated metadata, runs, metrics, params, and tags.
 
         Throws `RESOURCE_DOES_NOT_EXIST` if the run was never created or was permanently deleted.
 
@@ -7776,9 +8232,7 @@ class ExperimentsAPI:
     def restore_runs(
         self, experiment_id: str, min_timestamp_millis: int, *, max_runs: Optional[int] = None
     ) -> RestoreRunsResponse:
-        """Restore runs by deletion time.
-
-        Bulk restore runs in an experiment that were deleted no earlier than the specified timestamp. Restores
+        """Bulk restore runs in an experiment that were deleted no earlier than the specified timestamp. Restores
         at most max_runs per request. To call this API from a Databricks Notebook in Python, you can use the
         client code snippet on
 
@@ -7817,9 +8271,7 @@ class ExperimentsAPI:
         page_token: Optional[str] = None,
         view_type: Optional[ViewType] = None,
     ) -> Iterator[Experiment]:
-        """Search experiments.
-
-        Searches for experiments that satisfy specified search criteria.
+        """Searches for experiments that satisfy specified search criteria.
 
         :param filter: str (optional)
           String representing a SQL filter condition (e.g. "name ILIKE 'my-experiment%'")
@@ -7871,9 +8323,7 @@ class ExperimentsAPI:
         order_by: Optional[List[SearchLoggedModelsOrderBy]] = None,
         page_token: Optional[str] = None,
     ) -> SearchLoggedModelsResponse:
-        """Search logged models.
-
-        Search for Logged Models that satisfy specified search criteria.
+        """Search for Logged Models that satisfy specified search criteria.
 
         :param datasets: List[:class:`SearchLoggedModelsDataset`] (optional)
           List of datasets on which to apply the metrics filter clauses. For example, a filter with
@@ -7928,9 +8378,7 @@ class ExperimentsAPI:
         page_token: Optional[str] = None,
         run_view_type: Optional[ViewType] = None,
     ) -> Iterator[Run]:
-        """Search for runs.
-
-        Searches for runs that satisfy expressions.
+        """Searches for runs that satisfy expressions.
 
         Search expressions can use `mlflowMetric` and `mlflowParam` keys.
 
@@ -7990,9 +8438,7 @@ class ExperimentsAPI:
             body["page_token"] = json["next_page_token"]
 
     def set_experiment_tag(self, experiment_id: str, key: str, value: str):
-        """Set a tag for an experiment.
-
-        Sets a tag on an experiment. Experiment tags are metadata that can be updated.
+        """Sets a tag on an experiment. Experiment tags are metadata that can be updated.
 
         :param experiment_id: str
           ID of the experiment under which to log the tag. Must be provided.
@@ -8018,7 +8464,7 @@ class ExperimentsAPI:
         self._api.do("POST", "/api/2.0/mlflow/experiments/set-experiment-tag", body=body, headers=headers)
 
     def set_logged_model_tags(self, model_id: str, *, tags: Optional[List[LoggedModelTag]] = None):
-        """Set a tag for a logged model.
+        """Set tags for a logged model.
 
         :param model_id: str
           The ID of the logged model to set the tags on.
@@ -8040,9 +8486,7 @@ class ExperimentsAPI:
     def set_permissions(
         self, experiment_id: str, *, access_control_list: Optional[List[ExperimentAccessControlRequest]] = None
     ) -> ExperimentPermissions:
-        """Set experiment permissions.
-
-        Sets permissions on an object, replacing existing permissions if they exist. Deletes all direct
+        """Sets permissions on an object, replacing existing permissions if they exist. Deletes all direct
         permissions if none are specified. Objects can inherit permissions from their root object.
 
         :param experiment_id: str
@@ -8063,9 +8507,7 @@ class ExperimentsAPI:
         return ExperimentPermissions.from_dict(res)
 
     def set_tag(self, key: str, value: str, *, run_id: Optional[str] = None, run_uuid: Optional[str] = None):
-        """Set a tag for a run.
-
-        Sets a tag on a run. Tags are run metadata that can be updated during a run and after a run completes.
+        """Sets a tag on a run. Tags are run metadata that can be updated during a run and after a run completes.
 
         :param key: str
           Name of the tag. Keys up to 250 bytes in size are supported.
@@ -8096,9 +8538,7 @@ class ExperimentsAPI:
         self._api.do("POST", "/api/2.0/mlflow/runs/set-tag", body=body, headers=headers)
 
     def update_experiment(self, experiment_id: str, *, new_name: Optional[str] = None):
-        """Update an experiment.
-
-        Updates experiment metadata.
+        """Updates experiment metadata.
 
         :param experiment_id: str
           ID of the associated experiment.
@@ -8122,9 +8562,7 @@ class ExperimentsAPI:
     def update_permissions(
         self, experiment_id: str, *, access_control_list: Optional[List[ExperimentAccessControlRequest]] = None
     ) -> ExperimentPermissions:
-        """Update experiment permissions.
-
-        Updates the permissions on an experiment. Experiments can inherit permissions from their root object.
+        """Updates the permissions on an experiment. Experiments can inherit permissions from their root object.
 
         :param experiment_id: str
           The experiment for which to get or manage permissions.
@@ -8152,9 +8590,7 @@ class ExperimentsAPI:
         run_uuid: Optional[str] = None,
         status: Optional[UpdateRunStatus] = None,
     ) -> UpdateRunResponse:
-        """Update a run.
-
-        Updates run metadata.
+        """Updates run metadata.
 
         :param end_time: int (optional)
           Unix timestamp in milliseconds of when the run ended.
@@ -8190,6 +8626,146 @@ class ExperimentsAPI:
         return UpdateRunResponse.from_dict(res)
 
 
+class FeatureStoreAPI:
+    """A feature store is a centralized repository that enables data scientists to find and share features. Using
+    a feature store also ensures that the code used to compute feature values is the same during model
+    training and when the model is used for inference.
+
+    An online store is a low-latency database used for feature lookup during real-time model inference or
+    serve feature for real-time applications."""
+
+    def __init__(self, api_client):
+        self._api = api_client
+
+    def create_online_store(self, online_store: OnlineStore) -> OnlineStore:
+        """Create an Online Feature Store.
+
+        :param online_store: :class:`OnlineStore`
+          Online store to create.
+
+        :returns: :class:`OnlineStore`
+        """
+        body = online_store.as_dict()
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do("POST", "/api/2.0/feature-store/online-stores", body=body, headers=headers)
+        return OnlineStore.from_dict(res)
+
+    def delete_online_store(self, name: str):
+        """Delete an Online Feature Store.
+
+        :param name: str
+          Name of the online store to delete.
+
+
+        """
+
+        headers = {
+            "Accept": "application/json",
+        }
+
+        self._api.do("DELETE", f"/api/2.0/feature-store/online-stores/{name}", headers=headers)
+
+    def get_online_store(self, name: str) -> OnlineStore:
+        """Get an Online Feature Store.
+
+        :param name: str
+          Name of the online store to get.
+
+        :returns: :class:`OnlineStore`
+        """
+
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do("GET", f"/api/2.0/feature-store/online-stores/{name}", headers=headers)
+        return OnlineStore.from_dict(res)
+
+    def list_online_stores(
+        self, *, page_size: Optional[int] = None, page_token: Optional[str] = None
+    ) -> Iterator[OnlineStore]:
+        """List Online Feature Stores.
+
+        :param page_size: int (optional)
+          The maximum number of results to return. Defaults to 100 if not specified.
+        :param page_token: str (optional)
+          Pagination token to go to the next page based on a previous query.
+
+        :returns: Iterator over :class:`OnlineStore`
+        """
+
+        query = {}
+        if page_size is not None:
+            query["page_size"] = page_size
+        if page_token is not None:
+            query["page_token"] = page_token
+        headers = {
+            "Accept": "application/json",
+        }
+
+        while True:
+            json = self._api.do("GET", "/api/2.0/feature-store/online-stores", query=query, headers=headers)
+            if "online_stores" in json:
+                for v in json["online_stores"]:
+                    yield OnlineStore.from_dict(v)
+            if "next_page_token" not in json or not json["next_page_token"]:
+                return
+            query["page_token"] = json["next_page_token"]
+
+    def publish_table(self, source_table_name: str, publish_spec: PublishSpec) -> PublishTableResponse:
+        """Publish features.
+
+        :param source_table_name: str
+          The full three-part (catalog, schema, table) name of the source table.
+        :param publish_spec: :class:`PublishSpec`
+          The specification for publishing the online table from the source table.
+
+        :returns: :class:`PublishTableResponse`
+        """
+        body = {}
+        if publish_spec is not None:
+            body["publish_spec"] = publish_spec.as_dict()
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do(
+            "POST", f"/api/2.0/feature-store/tables/{source_table_name}/publish", body=body, headers=headers
+        )
+        return PublishTableResponse.from_dict(res)
+
+    def update_online_store(self, name: str, online_store: OnlineStore, update_mask: str) -> OnlineStore:
+        """Update an Online Feature Store.
+
+        :param name: str
+          The name of the online store. This is the unique identifier for the online store.
+        :param online_store: :class:`OnlineStore`
+          Online store to update.
+        :param update_mask: str
+          The list of fields to update.
+
+        :returns: :class:`OnlineStore`
+        """
+        body = online_store.as_dict()
+        query = {}
+        if update_mask is not None:
+            query["update_mask"] = update_mask
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do(
+            "PATCH", f"/api/2.0/feature-store/online-stores/{name}", query=query, body=body, headers=headers
+        )
+        return OnlineStore.from_dict(res)
+
+
 class ForecastingAPI:
     """The Forecasting API allows you to create and get serverless forecasting experiments"""
 
@@ -8252,9 +8828,7 @@ class ForecastingAPI:
         timeseries_identifier_columns: Optional[List[str]] = None,
         training_frameworks: Optional[List[str]] = None,
     ) -> Wait[ForecastingExperiment]:
-        """Create a forecasting experiment.
-
-        Creates a serverless forecasting experiment. Returns the experiment ID.
+        """Creates a serverless forecasting experiment. Returns the experiment ID.
 
         :param train_data_path: str
           The fully qualified path of a Unity Catalog table, formatted as catalog_name.schema_name.table_name,
@@ -8399,9 +8973,7 @@ class ForecastingAPI:
         ).result(timeout=timeout)
 
     def get_experiment(self, experiment_id: str) -> ForecastingExperiment:
-        """Get a forecasting experiment.
-
-        Public RPC to get forecasting experiment
+        """Public RPC to get forecasting experiment
 
         :param experiment_id: str
           The unique ID of a forecasting experiment
@@ -8417,6 +8989,179 @@ class ForecastingAPI:
         return ForecastingExperiment.from_dict(res)
 
 
+class MaterializedFeaturesAPI:
+    """Materialized Features are columns in tables and views that can be directly used as features to train and
+    serve ML models."""
+
+    def __init__(self, api_client):
+        self._api = api_client
+
+    def create_feature_tag(self, table_name: str, feature_name: str, feature_tag: FeatureTag) -> FeatureTag:
+        """Creates a FeatureTag.
+
+        :param table_name: str
+        :param feature_name: str
+        :param feature_tag: :class:`FeatureTag`
+
+        :returns: :class:`FeatureTag`
+        """
+        body = feature_tag.as_dict()
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do(
+            "POST",
+            f"/api/2.0/feature-store/feature-tables/{table_name}/features/{feature_name}/tags",
+            body=body,
+            headers=headers,
+        )
+        return FeatureTag.from_dict(res)
+
+    def delete_feature_tag(self, table_name: str, feature_name: str, key: str):
+        """Deletes a FeatureTag.
+
+        :param table_name: str
+          The name of the feature table.
+        :param feature_name: str
+          The name of the feature within the feature table.
+        :param key: str
+          The key of the tag to delete.
+
+
+        """
+
+        headers = {
+            "Accept": "application/json",
+        }
+
+        self._api.do(
+            "DELETE",
+            f"/api/2.0/feature-store/feature-tables/{table_name}/features/{feature_name}/tags/{key}",
+            headers=headers,
+        )
+
+    def get_feature_lineage(self, table_name: str, feature_name: str) -> FeatureLineage:
+        """Get Feature Lineage.
+
+        :param table_name: str
+          The full name of the feature table in Unity Catalog.
+        :param feature_name: str
+          The name of the feature.
+
+        :returns: :class:`FeatureLineage`
+        """
+
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do(
+            "GET",
+            f"/api/2.0/feature-store/feature-tables/{table_name}/features/{feature_name}/lineage",
+            headers=headers,
+        )
+        return FeatureLineage.from_dict(res)
+
+    def get_feature_tag(self, table_name: str, feature_name: str, key: str) -> FeatureTag:
+        """Gets a FeatureTag.
+
+        :param table_name: str
+        :param feature_name: str
+        :param key: str
+
+        :returns: :class:`FeatureTag`
+        """
+
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do(
+            "GET",
+            f"/api/2.0/feature-store/feature-tables/{table_name}/features/{feature_name}/tags/{key}",
+            headers=headers,
+        )
+        return FeatureTag.from_dict(res)
+
+    def list_feature_tags(
+        self, table_name: str, feature_name: str, *, page_size: Optional[int] = None, page_token: Optional[str] = None
+    ) -> Iterator[FeatureTag]:
+        """Lists FeatureTags.
+
+        :param table_name: str
+        :param feature_name: str
+        :param page_size: int (optional)
+          The maximum number of results to return.
+        :param page_token: str (optional)
+          Pagination token to go to the next page based on a previous query.
+
+        :returns: Iterator over :class:`FeatureTag`
+        """
+
+        query = {}
+        if page_size is not None:
+            query["page_size"] = page_size
+        if page_token is not None:
+            query["page_token"] = page_token
+        headers = {
+            "Accept": "application/json",
+        }
+
+        while True:
+            json = self._api.do(
+                "GET",
+                f"/api/2.0/feature-store/feature-tables/{table_name}/features/{feature_name}/tags",
+                query=query,
+                headers=headers,
+            )
+            if "feature_tags" in json:
+                for v in json["feature_tags"]:
+                    yield FeatureTag.from_dict(v)
+            if "next_page_token" not in json or not json["next_page_token"]:
+                return
+            query["page_token"] = json["next_page_token"]
+
+    def update_feature_tag(
+        self,
+        table_name: str,
+        feature_name: str,
+        key: str,
+        feature_tag: FeatureTag,
+        *,
+        update_mask: Optional[str] = None,
+    ) -> FeatureTag:
+        """Updates a FeatureTag.
+
+        :param table_name: str
+        :param feature_name: str
+        :param key: str
+        :param feature_tag: :class:`FeatureTag`
+        :param update_mask: str (optional)
+          The list of fields to update.
+
+        :returns: :class:`FeatureTag`
+        """
+        body = feature_tag.as_dict()
+        query = {}
+        if update_mask is not None:
+            query["update_mask"] = update_mask
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do(
+            "PATCH",
+            f"/api/2.0/feature-store/feature-tables/{table_name}/features/{feature_name}/tags/{key}",
+            query=query,
+            body=body,
+            headers=headers,
+        )
+        return FeatureTag.from_dict(res)
+
+
 class ModelRegistryAPI:
     """Note: This API reference documents APIs for the Workspace Model Registry. Databricks recommends using
     [Models in Unity Catalog](/api/workspace/registeredmodels) instead. Models in Unity Catalog provides
@@ -8430,17 +9175,15 @@ class ModelRegistryAPI:
         self._api = api_client
 
     def approve_transition_request(
-        self, name: str, version: str, stage: Stage, archive_existing_versions: bool, *, comment: Optional[str] = None
+        self, name: str, version: str, stage: str, archive_existing_versions: bool, *, comment: Optional[str] = None
     ) -> ApproveTransitionRequestResponse:
-        """Approve transition request.
-
-        Approves a model version stage transition request.
+        """Approves a model version stage transition request.
 
         :param name: str
           Name of the model.
         :param version: str
           Version of the model.
-        :param stage: :class:`Stage`
+        :param stage: str
           Target stage of the transition. Valid values are:
 
           * `None`: The initial stage of a model version.
@@ -8465,7 +9208,7 @@ class ModelRegistryAPI:
         if name is not None:
             body["name"] = name
         if stage is not None:
-            body["stage"] = stage.value
+            body["stage"] = stage
         if version is not None:
             body["version"] = version
         headers = {
@@ -8477,9 +9220,7 @@ class ModelRegistryAPI:
         return ApproveTransitionRequestResponse.from_dict(res)
 
     def create_comment(self, name: str, version: str, comment: str) -> CreateCommentResponse:
-        """Post a comment.
-
-        Posts a comment on a model version. A comment can be submitted either by a user or programmatically to
+        """Posts a comment on a model version. A comment can be submitted either by a user or programmatically to
         display relevant information about the model. For example, test results or deployment errors.
 
         :param name: str
@@ -8509,11 +9250,8 @@ class ModelRegistryAPI:
     def create_model(
         self, name: str, *, description: Optional[str] = None, tags: Optional[List[ModelTag]] = None
     ) -> CreateModelResponse:
-        """Create a model.
-
-        Creates a new registered model with the name specified in the request body.
-
-        Throws `RESOURCE_ALREADY_EXISTS` if a registered model with the given name exists.
+        """Creates a new registered model with the name specified in the request body. Throws
+        `RESOURCE_ALREADY_EXISTS` if a registered model with the given name exists.
 
         :param name: str
           Register models under this name
@@ -8549,9 +9287,7 @@ class ModelRegistryAPI:
         run_link: Optional[str] = None,
         tags: Optional[List[ModelVersionTag]] = None,
     ) -> CreateModelVersionResponse:
-        """Create a model version.
-
-        Creates a model version.
+        """Creates a model version.
 
         :param name: str
           Register model under this name
@@ -8592,17 +9328,15 @@ class ModelRegistryAPI:
         return CreateModelVersionResponse.from_dict(res)
 
     def create_transition_request(
-        self, name: str, version: str, stage: Stage, *, comment: Optional[str] = None
+        self, name: str, version: str, stage: str, *, comment: Optional[str] = None
     ) -> CreateTransitionRequestResponse:
-        """Make a transition request.
-
-        Creates a model version stage transition request.
+        """Creates a model version stage transition request.
 
         :param name: str
           Name of the model.
         :param version: str
           Version of the model.
-        :param stage: :class:`Stage`
+        :param stage: str
           Target stage of the transition. Valid values are:
 
           * `None`: The initial stage of a model version.
@@ -8623,7 +9357,7 @@ class ModelRegistryAPI:
         if name is not None:
             body["name"] = name
         if stage is not None:
-            body["stage"] = stage.value
+            body["stage"] = stage
         if version is not None:
             body["version"] = version
         headers = {
@@ -8644,11 +9378,7 @@ class ModelRegistryAPI:
         model_name: Optional[str] = None,
         status: Optional[RegistryWebhookStatus] = None,
     ) -> CreateWebhookResponse:
-        """Create a webhook.
-
-        **NOTE**: This endpoint is in Public Preview.
-
-        Creates a registry webhook.
+        """**NOTE:** This endpoint is in Public Preview. Creates a registry webhook.
 
         :param events: List[:class:`RegistryWebhookEvent`]
           Events that can trigger a registry webhook: * `MODEL_VERSION_CREATED`: A new model version was
@@ -8682,7 +9412,9 @@ class ModelRegistryAPI:
         :param description: str (optional)
           User-specified description for the webhook.
         :param http_url_spec: :class:`HttpUrlSpec` (optional)
+          External HTTPS URL called on event trigger (by using a POST request).
         :param job_spec: :class:`JobSpec` (optional)
+          ID of the job that the webhook runs.
         :param model_name: str (optional)
           If model name is not specified, a registry-wide webhook is created that listens for the specified
           events across all versions of all registered models.
@@ -8719,9 +9451,7 @@ class ModelRegistryAPI:
         return CreateWebhookResponse.from_dict(res)
 
     def delete_comment(self, id: str):
-        """Delete a comment.
-
-        Deletes a comment on a model version.
+        """Deletes a comment on a model version.
 
         :param id: str
           Unique identifier of an activity
@@ -8739,9 +9469,7 @@ class ModelRegistryAPI:
         self._api.do("DELETE", "/api/2.0/mlflow/comments/delete", query=query, headers=headers)
 
     def delete_model(self, name: str):
-        """Delete a model.
-
-        Deletes a registered model.
+        """Deletes a registered model.
 
         :param name: str
           Registered model unique name identifier.
@@ -8759,9 +9487,7 @@ class ModelRegistryAPI:
         self._api.do("DELETE", "/api/2.0/mlflow/registered-models/delete", query=query, headers=headers)
 
     def delete_model_tag(self, name: str, key: str):
-        """Delete a model tag.
-
-        Deletes the tag for a registered model.
+        """Deletes the tag for a registered model.
 
         :param name: str
           Name of the registered model that the tag was logged under.
@@ -8784,9 +9510,7 @@ class ModelRegistryAPI:
         self._api.do("DELETE", "/api/2.0/mlflow/registered-models/delete-tag", query=query, headers=headers)
 
     def delete_model_version(self, name: str, version: str):
-        """Delete a model version.
-
-        Deletes a model version.
+        """Deletes a model version.
 
         :param name: str
           Name of the registered model
@@ -8808,9 +9532,7 @@ class ModelRegistryAPI:
         self._api.do("DELETE", "/api/2.0/mlflow/model-versions/delete", query=query, headers=headers)
 
     def delete_model_version_tag(self, name: str, version: str, key: str):
-        """Delete a model version tag.
-
-        Deletes a model version tag.
+        """Deletes a model version tag.
 
         :param name: str
           Name of the registered model that the tag was logged under.
@@ -8837,23 +9559,15 @@ class ModelRegistryAPI:
         self._api.do("DELETE", "/api/2.0/mlflow/model-versions/delete-tag", query=query, headers=headers)
 
     def delete_transition_request(
-        self,
-        name: str,
-        version: str,
-        stage: DeleteTransitionRequestStage,
-        creator: str,
-        *,
-        comment: Optional[str] = None,
-    ):
-        """Delete a transition request.
-
-        Cancels a model version stage transition request.
+        self, name: str, version: str, stage: str, creator: str, *, comment: Optional[str] = None
+    ) -> DeleteTransitionRequestResponse:
+        """Cancels a model version stage transition request.
 
         :param name: str
           Name of the model.
         :param version: str
           Version of the model.
-        :param stage: :class:`DeleteTransitionRequestStage`
+        :param stage: str
           Target stage of the transition request. Valid values are:
 
           * `None`: The initial stage of a model version.
@@ -8869,7 +9583,7 @@ class ModelRegistryAPI:
         :param comment: str (optional)
           User-provided comment on the action.
 
-
+        :returns: :class:`DeleteTransitionRequestResponse`
         """
 
         query = {}
@@ -8880,23 +9594,20 @@ class ModelRegistryAPI:
         if name is not None:
             query["name"] = name
         if stage is not None:
-            query["stage"] = stage.value
+            query["stage"] = stage
         if version is not None:
             query["version"] = version
         headers = {
             "Accept": "application/json",
         }
 
-        self._api.do("DELETE", "/api/2.0/mlflow/transition-requests/delete", query=query, headers=headers)
-
-    def delete_webhook(self, *, id: Optional[str] = None):
-        """Delete a webhook.
+        res = self._api.do("DELETE", "/api/2.0/mlflow/transition-requests/delete", query=query, headers=headers)
+        return DeleteTransitionRequestResponse.from_dict(res)
 
-        **NOTE:** This endpoint is in Public Preview.
+    def delete_webhook(self, id: str):
+        """**NOTE:** This endpoint is in Public Preview. Deletes a registry webhook.
 
-        Deletes a registry webhook.
-
-        :param id: str (optional)
+        :param id: str
           Webhook ID required to delete a registry webhook.
 
 
@@ -8912,9 +9623,7 @@ class ModelRegistryAPI:
         self._api.do("DELETE", "/api/2.0/mlflow/registry-webhooks/delete", query=query, headers=headers)
 
     def get_latest_versions(self, name: str, *, stages: Optional[List[str]] = None) -> Iterator[ModelVersion]:
-        """Get the latest version.
-
-        Gets the latest version of a registered model.
+        """Gets the latest version of a registered model.
 
         :param name: str
           Registered model unique name identifier.
@@ -8938,9 +9647,7 @@ class ModelRegistryAPI:
         return parsed if parsed is not None else []
 
     def get_model(self, name: str) -> GetModelResponse:
-        """Get model.
-
-        Get the details of a model. This is a Databricks workspace version of the [MLflow endpoint] that also
+        """Get the details of a model. This is a Databricks workspace version of the [MLflow endpoint] that also
         returns the model's Databricks workspace ID and the permission level of the requesting user on the
         model.
 
@@ -8965,8 +9672,6 @@ class ModelRegistryAPI:
     def get_model_version(self, name: str, version: str) -> GetModelVersionResponse:
         """Get a model version.
 
-        Get a model version.
-
         :param name: str
           Name of the registered model
         :param version: str
@@ -8988,9 +9693,7 @@ class ModelRegistryAPI:
         return GetModelVersionResponse.from_dict(res)
 
     def get_model_version_download_uri(self, name: str, version: str) -> GetModelVersionDownloadUriResponse:
-        """Get a model version URI.
-
-        Gets a URI to download the model version.
+        """Gets a URI to download the model version.
 
         :param name: str
           Name of the registered model
@@ -9013,9 +9716,7 @@ class ModelRegistryAPI:
         return GetModelVersionDownloadUriResponse.from_dict(res)
 
     def get_permission_levels(self, registered_model_id: str) -> GetRegisteredModelPermissionLevelsResponse:
-        """Get registered model permission levels.
-
-        Gets the permission levels that a user can have on an object.
+        """Gets the permission levels that a user can have on an object.
 
         :param registered_model_id: str
           The registered model for which to get or manage permissions.
@@ -9033,9 +9734,7 @@ class ModelRegistryAPI:
         return GetRegisteredModelPermissionLevelsResponse.from_dict(res)
 
     def get_permissions(self, registered_model_id: str) -> RegisteredModelPermissions:
-        """Get registered model permissions.
-
-        Gets the permissions of a registered model. Registered models can inherit permissions from their root
+        """Gets the permissions of a registered model. Registered models can inherit permissions from their root
         object.
 
         :param registered_model_id: str
@@ -9052,9 +9751,7 @@ class ModelRegistryAPI:
         return RegisteredModelPermissions.from_dict(res)
 
     def list_models(self, *, max_results: Optional[int] = None, page_token: Optional[str] = None) -> Iterator[Model]:
-        """List models.
-
-        Lists all available registered models, up to the limit specified in __max_results__.
+        """Lists all available registered models, up to the limit specified in __max_results__.
 
         :param max_results: int (optional)
           Maximum number of registered models desired. Max threshold is 1000.
@@ -9083,12 +9780,10 @@ class ModelRegistryAPI:
             query["page_token"] = json["next_page_token"]
 
     def list_transition_requests(self, name: str, version: str) -> Iterator[Activity]:
-        """List transition requests.
-
-        Gets a list of all open stage transition requests for the model version.
+        """Gets a list of all open stage transition requests for the model version.
 
         :param name: str
-          Name of the model.
+          Name of the registered model.
         :param version: str
           Version of the model.
 
@@ -9112,21 +9807,48 @@ class ModelRegistryAPI:
         self,
         *,
         events: Optional[List[RegistryWebhookEvent]] = None,
+        max_results: Optional[int] = None,
         model_name: Optional[str] = None,
         page_token: Optional[str] = None,
     ) -> Iterator[RegistryWebhook]:
-        """List registry webhooks.
+        """**NOTE:** This endpoint is in Public Preview. Lists all registry webhooks.
 
-        **NOTE:** This endpoint is in Public Preview.
+        :param events: List[:class:`RegistryWebhookEvent`] (optional)
+          Events that trigger the webhook. * `MODEL_VERSION_CREATED`: A new model version was created for the
+          associated model.
 
-        Lists all registry webhooks.
+          * `MODEL_VERSION_TRANSITIONED_STAGE`: A model version’s stage was changed.
+
+          * `TRANSITION_REQUEST_CREATED`: A user requested a model version’s stage be transitioned.
+
+          * `COMMENT_CREATED`: A user wrote a comment on a registered model.
+
+          * `REGISTERED_MODEL_CREATED`: A new registered model was created. This event type can only be
+          specified for a registry-wide webhook, which can be created by not specifying a model name in the
+          create request.
+
+          * `MODEL_VERSION_TAG_SET`: A user set a tag on the model version.
+
+          * `MODEL_VERSION_TRANSITIONED_TO_STAGING`: A model version was transitioned to staging.
+
+          * `MODEL_VERSION_TRANSITIONED_TO_PRODUCTION`: A model version was transitioned to production.
+
+          * `MODEL_VERSION_TRANSITIONED_TO_ARCHIVED`: A model version was archived.
+
+          * `TRANSITION_REQUEST_TO_STAGING_CREATED`: A user requested a model version be transitioned to
+          staging.
+
+          * `TRANSITION_REQUEST_TO_PRODUCTION_CREATED`: A user requested a model version be transitioned to
+          production.
+
+          * `TRANSITION_REQUEST_TO_ARCHIVED_CREATED`: A user requested a model version be archived.
 
-        :param events: List[:class:`RegistryWebhookEvent`] (optional)
           If `events` is specified, any webhook with one or more of the specified trigger events is included
           in the output. If `events` is not specified, webhooks of all event types are included in the output.
+        :param max_results: int (optional)
         :param model_name: str (optional)
-          If not specified, all webhooks associated with the specified events are listed, regardless of their
-          associated model.
+          Registered model name If not specified, all webhooks associated with the specified events are
+          listed, regardless of their associated model.
         :param page_token: str (optional)
           Token indicating the page of artifact results to fetch
 
@@ -9136,6 +9858,8 @@ class ModelRegistryAPI:
         query = {}
         if events is not None:
             query["events"] = [v.value for v in events]
+        if max_results is not None:
+            query["max_results"] = max_results
         if model_name is not None:
             query["model_name"] = model_name
         if page_token is not None:
@@ -9154,17 +9878,15 @@ class ModelRegistryAPI:
             query["page_token"] = json["next_page_token"]
 
     def reject_transition_request(
-        self, name: str, version: str, stage: Stage, *, comment: Optional[str] = None
+        self, name: str, version: str, stage: str, *, comment: Optional[str] = None
     ) -> RejectTransitionRequestResponse:
-        """Reject a transition request.
-
-        Rejects a model version stage transition request.
+        """Rejects a model version stage transition request.
 
         :param name: str
           Name of the model.
         :param version: str
           Version of the model.
-        :param stage: :class:`Stage`
+        :param stage: str
           Target stage of the transition. Valid values are:
 
           * `None`: The initial stage of a model version.
@@ -9185,7 +9907,7 @@ class ModelRegistryAPI:
         if name is not None:
             body["name"] = name
         if stage is not None:
-            body["stage"] = stage.value
+            body["stage"] = stage
         if version is not None:
             body["version"] = version
         headers = {
@@ -9197,9 +9919,7 @@ class ModelRegistryAPI:
         return RejectTransitionRequestResponse.from_dict(res)
 
     def rename_model(self, name: str, *, new_name: Optional[str] = None) -> RenameModelResponse:
-        """Rename a model.
-
-        Renames a registered model.
+        """Renames a registered model.
 
         :param name: str
           Registered model unique name identifier.
@@ -9229,9 +9949,7 @@ class ModelRegistryAPI:
         order_by: Optional[List[str]] = None,
         page_token: Optional[str] = None,
     ) -> Iterator[ModelVersion]:
-        """Searches model versions.
-
-        Searches for specific model versions based on the supplied __filter__.
+        """Searches for specific model versions based on the supplied __filter__.
 
         :param filter: str (optional)
           String filter condition, like "name='my-model-name'". Must be a single boolean condition, with
@@ -9278,9 +9996,7 @@ class ModelRegistryAPI:
         order_by: Optional[List[str]] = None,
         page_token: Optional[str] = None,
     ) -> Iterator[Model]:
-        """Search models.
-
-        Search for registered models based on the specified __filter__.
+        """Search for registered models based on the specified __filter__.
 
         :param filter: str (optional)
           String filter condition, like "name LIKE 'my-model-name'". Interpreted in the backend automatically
@@ -9321,9 +10037,7 @@ class ModelRegistryAPI:
             query["page_token"] = json["next_page_token"]
 
     def set_model_tag(self, name: str, key: str, value: str):
-        """Set a tag.
-
-        Sets a tag on a registered model.
+        """Sets a tag on a registered model.
 
         :param name: str
           Unique name of the model.
@@ -9352,9 +10066,7 @@ class ModelRegistryAPI:
         self._api.do("POST", "/api/2.0/mlflow/registered-models/set-tag", body=body, headers=headers)
 
     def set_model_version_tag(self, name: str, version: str, key: str, value: str):
-        """Set a version tag.
-
-        Sets a model version tag.
+        """Sets a model version tag.
 
         :param name: str
           Unique name of the model.
@@ -9392,9 +10104,7 @@ class ModelRegistryAPI:
         *,
         access_control_list: Optional[List[RegisteredModelAccessControlRequest]] = None,
     ) -> RegisteredModelPermissions:
-        """Set registered model permissions.
-
-        Sets permissions on an object, replacing existing permissions if they exist. Deletes all direct
+        """Sets permissions on an object, replacing existing permissions if they exist. Deletes all direct
         permissions if none are specified. Objects can inherit permissions from their root object.
 
         :param registered_model_id: str
@@ -9419,11 +10129,7 @@ class ModelRegistryAPI:
     def test_registry_webhook(
         self, id: str, *, event: Optional[RegistryWebhookEvent] = None
     ) -> TestRegistryWebhookResponse:
-        """Test a webhook.
-
-        **NOTE:** This endpoint is in Public Preview.
-
-        Tests a registry webhook.
+        """**NOTE:** This endpoint is in Public Preview. Tests a registry webhook.
 
         :param id: str
           Webhook ID
@@ -9447,12 +10153,10 @@ class ModelRegistryAPI:
         return TestRegistryWebhookResponse.from_dict(res)
 
     def transition_stage(
-        self, name: str, version: str, stage: Stage, archive_existing_versions: bool, *, comment: Optional[str] = None
+        self, name: str, version: str, stage: str, archive_existing_versions: bool, *, comment: Optional[str] = None
     ) -> TransitionStageResponse:
-        """Transition a stage.
-
-        Transition a model version's stage. This is a Databricks workspace version of the [MLflow endpoint]
-        that also accepts a comment associated with the transition to be recorded.",
+        """Transition a model version's stage. This is a Databricks workspace version of the [MLflow endpoint]
+        that also accepts a comment associated with the transition to be recorded.
 
         [MLflow endpoint]: https://www.mlflow.org/docs/latest/rest-api.html#transition-modelversion-stage
 
@@ -9460,7 +10164,7 @@ class ModelRegistryAPI:
           Name of the model.
         :param version: str
           Version of the model.
-        :param stage: :class:`Stage`
+        :param stage: str
           Target stage of the transition. Valid values are:
 
           * `None`: The initial stage of a model version.
@@ -9485,7 +10189,7 @@ class ModelRegistryAPI:
         if name is not None:
             body["name"] = name
         if stage is not None:
-            body["stage"] = stage.value
+            body["stage"] = stage
         if version is not None:
             body["version"] = version
         headers = {
@@ -9499,9 +10203,7 @@ class ModelRegistryAPI:
         return TransitionStageResponse.from_dict(res)
 
     def update_comment(self, id: str, comment: str) -> UpdateCommentResponse:
-        """Update a comment.
-
-        Post an edit to a comment on a model version.
+        """Post an edit to a comment on a model version.
 
         :param id: str
           Unique identifier of an activity
@@ -9523,17 +10225,15 @@ class ModelRegistryAPI:
         res = self._api.do("PATCH", "/api/2.0/mlflow/comments/update", body=body, headers=headers)
         return UpdateCommentResponse.from_dict(res)
 
-    def update_model(self, name: str, *, description: Optional[str] = None):
-        """Update model.
-
-        Updates a registered model.
+    def update_model(self, name: str, *, description: Optional[str] = None) -> UpdateModelResponse:
+        """Updates a registered model.
 
         :param name: str
           Registered model unique name identifier.
         :param description: str (optional)
           If provided, updates the description for this `registered_model`.
 
-
+        :returns: :class:`UpdateModelResponse`
         """
         body = {}
         if description is not None:
@@ -9545,12 +10245,13 @@ class ModelRegistryAPI:
             "Content-Type": "application/json",
         }
 
-        self._api.do("PATCH", "/api/2.0/mlflow/registered-models/update", body=body, headers=headers)
-
-    def update_model_version(self, name: str, version: str, *, description: Optional[str] = None):
-        """Update model version.
+        res = self._api.do("PATCH", "/api/2.0/mlflow/registered-models/update", body=body, headers=headers)
+        return UpdateModelResponse.from_dict(res)
 
-        Updates the model version.
+    def update_model_version(
+        self, name: str, version: str, *, description: Optional[str] = None
+    ) -> UpdateModelVersionResponse:
+        """Updates the model version.
 
         :param name: str
           Name of the registered model
@@ -9559,7 +10260,7 @@ class ModelRegistryAPI:
         :param description: str (optional)
           If provided, updates the description for this `registered_model`.
 
-
+        :returns: :class:`UpdateModelVersionResponse`
         """
         body = {}
         if description is not None:
@@ -9573,7 +10274,8 @@ class ModelRegistryAPI:
             "Content-Type": "application/json",
         }
 
-        self._api.do("PATCH", "/api/2.0/mlflow/model-versions/update", body=body, headers=headers)
+        res = self._api.do("PATCH", "/api/2.0/mlflow/model-versions/update", body=body, headers=headers)
+        return UpdateModelVersionResponse.from_dict(res)
 
     def update_permissions(
         self,
@@ -9581,9 +10283,7 @@ class ModelRegistryAPI:
         *,
         access_control_list: Optional[List[RegisteredModelAccessControlRequest]] = None,
     ) -> RegisteredModelPermissions:
-        """Update registered model permissions.
-
-        Updates the permissions on a registered model. Registered models can inherit permissions from their
+        """Updates the permissions on a registered model. Registered models can inherit permissions from their
         root object.
 
         :param registered_model_id: str
@@ -9614,12 +10314,8 @@ class ModelRegistryAPI:
         http_url_spec: Optional[HttpUrlSpec] = None,
         job_spec: Optional[JobSpec] = None,
         status: Optional[RegistryWebhookStatus] = None,
-    ):
-        """Update a webhook.
-
-        **NOTE:** This endpoint is in Public Preview.
-
-        Updates a registry webhook.
+    ) -> UpdateWebhookResponse:
+        """**NOTE:** This endpoint is in Public Preview. Updates a registry webhook.
 
         :param id: str
           Webhook ID
@@ -9657,15 +10353,8 @@ class ModelRegistryAPI:
         :param http_url_spec: :class:`HttpUrlSpec` (optional)
         :param job_spec: :class:`JobSpec` (optional)
         :param status: :class:`RegistryWebhookStatus` (optional)
-          Enable or disable triggering the webhook, or put the webhook into test mode. The default is
-          `ACTIVE`: * `ACTIVE`: Webhook is triggered when an associated event happens.
-
-          * `DISABLED`: Webhook is not triggered.
-
-          * `TEST_MODE`: Webhook can be triggered through the test endpoint, but is not triggered on a real
-          event.
-
 
+        :returns: :class:`UpdateWebhookResponse`
         """
         body = {}
         if description is not None:
@@ -9685,4 +10374,5 @@ class ModelRegistryAPI:
             "Content-Type": "application/json",
         }
 
-        self._api.do("PATCH", "/api/2.0/mlflow/registry-webhooks/update", body=body, headers=headers)
+        res = self._api.do("PATCH", "/api/2.0/mlflow/registry-webhooks/update", body=body, headers=headers)
+        return UpdateWebhookResponse.from_dict(res)