databricks-sdk 0.57.0__py3-none-any.whl → 0.59.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"
 
 
@@ -179,77 +174,10 @@ class ActivityType(Enum):
     SYSTEM_TRANSITION = "SYSTEM_TRANSITION"
 
 
-@dataclass
-class ApproveTransitionRequest:
-    name: str
-    """Name of the model."""
-
-    version: str
-    """Version of the model."""
-
-    stage: Stage
-    """Target stage of the transition. Valid values are:
-    
-    * `None`: The initial stage of a model version.
-    
-    * `Staging`: Staging or pre-production stage.
-    
-    * `Production`: Production stage.
-    
-    * `Archived`: Archived stage."""
-
-    archive_existing_versions: bool
-    """Specifies whether to archive all current model versions in the target stage."""
-
-    comment: Optional[str] = None
-    """User-provided comment on the action."""
-
-    def as_dict(self) -> dict:
-        """Serializes the ApproveTransitionRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.archive_existing_versions is not None:
-            body["archive_existing_versions"] = self.archive_existing_versions
-        if self.comment is not None:
-            body["comment"] = self.comment
-        if self.name is not None:
-            body["name"] = self.name
-        if self.stage is not None:
-            body["stage"] = self.stage.value
-        if self.version is not None:
-            body["version"] = self.version
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the ApproveTransitionRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.archive_existing_versions is not None:
-            body["archive_existing_versions"] = self.archive_existing_versions
-        if self.comment is not None:
-            body["comment"] = self.comment
-        if self.name is not None:
-            body["name"] = self.name
-        if self.stage is not None:
-            body["stage"] = self.stage
-        if self.version is not None:
-            body["version"] = self.version
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> ApproveTransitionRequest:
-        """Deserializes the ApproveTransitionRequest from a dictionary."""
-        return cls(
-            archive_existing_versions=d.get("archive_existing_versions", None),
-            comment=d.get("comment", None),
-            name=d.get("name", None),
-            stage=_enum(d, "stage", Stage),
-            version=d.get("version", None),
-        )
-
-
 @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 +200,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."""
@@ -350,49 +289,10 @@ class CommentObject:
         )
 
 
-@dataclass
-class CreateComment:
-    name: str
-    """Name of the model."""
-
-    version: str
-    """Version of the model."""
-
-    comment: str
-    """User-provided comment on the action."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateComment into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.comment is not None:
-            body["comment"] = self.comment
-        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 CreateComment into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.comment is not None:
-            body["comment"] = self.comment
-        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]) -> CreateComment:
-        """Deserializes the CreateComment from a dictionary."""
-        return cls(comment=d.get("comment", None), name=d.get("name", None), version=d.get("version", None))
-
-
 @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."""
@@ -414,53 +314,6 @@ class CreateCommentResponse:
         return cls(comment=_from_dict(d, "comment", CommentObject))
 
 
-@dataclass
-class CreateExperiment:
-    name: str
-    """Experiment name."""
-
-    artifact_location: Optional[str] = None
-    """Location where all artifacts for the experiment are stored. If not provided, the remote server
-    will select an appropriate default."""
-
-    tags: Optional[List[ExperimentTag]] = None
-    """A collection of tags to set on the experiment. Maximum tag size and number of tags per request
-    depends on the storage backend. All storage backends are guaranteed to support tag keys up to
-    250 bytes in size and tag values up to 5000 bytes in size. All storage backends are also
-    guaranteed to support up to 20 tags per request."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateExperiment into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.artifact_location is not None:
-            body["artifact_location"] = self.artifact_location
-        if self.name is not None:
-            body["name"] = self.name
-        if self.tags:
-            body["tags"] = [v.as_dict() for v in self.tags]
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateExperiment into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.artifact_location is not None:
-            body["artifact_location"] = self.artifact_location
-        if self.name is not None:
-            body["name"] = self.name
-        if self.tags:
-            body["tags"] = self.tags
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateExperiment:
-        """Deserializes the CreateExperiment from a dictionary."""
-        return cls(
-            artifact_location=d.get("artifact_location", None),
-            name=d.get("name", None),
-            tags=_repeated_dict(d, "tags", ExperimentTag),
-        )
-
-
 @dataclass
 class CreateExperimentResponse:
     experiment_id: Optional[str] = None
@@ -486,177 +339,6 @@ class CreateExperimentResponse:
         return cls(experiment_id=d.get("experiment_id", None))
 
 
-@dataclass
-class CreateForecastingExperimentRequest:
-    train_data_path: str
-    """The fully qualified path of a Unity Catalog table, formatted as
-    catalog_name.schema_name.table_name, used as training data for the forecasting model."""
-
-    target_column: str
-    """The column in the input training table used as the prediction target for model training. The
-    values in this column are used as the ground truth for model training."""
-
-    time_column: str
-    """The column in the input training table that represents each row's timestamp."""
-
-    forecast_granularity: str
-    """The time interval between consecutive rows in the time series data. Possible values include: '1
-    second', '1 minute', '5 minutes', '10 minutes', '15 minutes', '30 minutes', 'Hourly', 'Daily',
-    'Weekly', 'Monthly', 'Quarterly', 'Yearly'."""
-
-    forecast_horizon: int
-    """The number of time steps into the future to make predictions, calculated as a multiple of
-    forecast_granularity. This value represents how far ahead the model should forecast."""
-
-    custom_weights_column: Optional[str] = None
-    """The column in the training table used to customize weights for each time series."""
-
-    experiment_path: Optional[str] = None
-    """The path in the workspace to store the created experiment."""
-
-    future_feature_data_path: Optional[str] = None
-    """The fully qualified path of a Unity Catalog table, formatted as
-    catalog_name.schema_name.table_name, used to store future feature data for predictions."""
-
-    holiday_regions: Optional[List[str]] = None
-    """The region code(s) to automatically add holiday features. Currently supports only one region."""
-
-    include_features: Optional[List[str]] = None
-    """Specifies the list of feature columns to include in model training. These columns must exist in
-    the training data and be of type string, numerical, or boolean. If not specified, no additional
-    features will be included. Note: Certain columns are automatically handled: - Automatically
-    excluded: split_column, target_column, custom_weights_column. - Automatically included:
-    time_column."""
-
-    max_runtime: Optional[int] = None
-    """The maximum duration for the experiment in minutes. The experiment stops automatically if it
-    exceeds this limit."""
-
-    prediction_data_path: Optional[str] = None
-    """The fully qualified path of a Unity Catalog table, formatted as
-    catalog_name.schema_name.table_name, used to store predictions."""
-
-    primary_metric: Optional[str] = None
-    """The evaluation metric used to optimize the forecasting model."""
-
-    register_to: Optional[str] = None
-    """The fully qualified path of a Unity Catalog model, formatted as
-    catalog_name.schema_name.model_name, used to store the best model."""
-
-    split_column: Optional[str] = None
-    """// The column in the training table used for custom data splits. Values must be 'train',
-    'validate', or 'test'."""
-
-    timeseries_identifier_columns: Optional[List[str]] = None
-    """The column in the training table used to group the dataset for predicting individual time
-    series."""
-
-    training_frameworks: Optional[List[str]] = None
-    """List of frameworks to include for model tuning. Possible values are 'Prophet', 'ARIMA',
-    'DeepAR'. An empty list includes all supported frameworks."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateForecastingExperimentRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.custom_weights_column is not None:
-            body["custom_weights_column"] = self.custom_weights_column
-        if self.experiment_path is not None:
-            body["experiment_path"] = self.experiment_path
-        if self.forecast_granularity is not None:
-            body["forecast_granularity"] = self.forecast_granularity
-        if self.forecast_horizon is not None:
-            body["forecast_horizon"] = self.forecast_horizon
-        if self.future_feature_data_path is not None:
-            body["future_feature_data_path"] = self.future_feature_data_path
-        if self.holiday_regions:
-            body["holiday_regions"] = [v for v in self.holiday_regions]
-        if self.include_features:
-            body["include_features"] = [v for v in self.include_features]
-        if self.max_runtime is not None:
-            body["max_runtime"] = self.max_runtime
-        if self.prediction_data_path is not None:
-            body["prediction_data_path"] = self.prediction_data_path
-        if self.primary_metric is not None:
-            body["primary_metric"] = self.primary_metric
-        if self.register_to is not None:
-            body["register_to"] = self.register_to
-        if self.split_column is not None:
-            body["split_column"] = self.split_column
-        if self.target_column is not None:
-            body["target_column"] = self.target_column
-        if self.time_column is not None:
-            body["time_column"] = self.time_column
-        if self.timeseries_identifier_columns:
-            body["timeseries_identifier_columns"] = [v for v in self.timeseries_identifier_columns]
-        if self.train_data_path is not None:
-            body["train_data_path"] = self.train_data_path
-        if self.training_frameworks:
-            body["training_frameworks"] = [v for v in self.training_frameworks]
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateForecastingExperimentRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.custom_weights_column is not None:
-            body["custom_weights_column"] = self.custom_weights_column
-        if self.experiment_path is not None:
-            body["experiment_path"] = self.experiment_path
-        if self.forecast_granularity is not None:
-            body["forecast_granularity"] = self.forecast_granularity
-        if self.forecast_horizon is not None:
-            body["forecast_horizon"] = self.forecast_horizon
-        if self.future_feature_data_path is not None:
-            body["future_feature_data_path"] = self.future_feature_data_path
-        if self.holiday_regions:
-            body["holiday_regions"] = self.holiday_regions
-        if self.include_features:
-            body["include_features"] = self.include_features
-        if self.max_runtime is not None:
-            body["max_runtime"] = self.max_runtime
-        if self.prediction_data_path is not None:
-            body["prediction_data_path"] = self.prediction_data_path
-        if self.primary_metric is not None:
-            body["primary_metric"] = self.primary_metric
-        if self.register_to is not None:
-            body["register_to"] = self.register_to
-        if self.split_column is not None:
-            body["split_column"] = self.split_column
-        if self.target_column is not None:
-            body["target_column"] = self.target_column
-        if self.time_column is not None:
-            body["time_column"] = self.time_column
-        if self.timeseries_identifier_columns:
-            body["timeseries_identifier_columns"] = self.timeseries_identifier_columns
-        if self.train_data_path is not None:
-            body["train_data_path"] = self.train_data_path
-        if self.training_frameworks:
-            body["training_frameworks"] = self.training_frameworks
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateForecastingExperimentRequest:
-        """Deserializes the CreateForecastingExperimentRequest from a dictionary."""
-        return cls(
-            custom_weights_column=d.get("custom_weights_column", None),
-            experiment_path=d.get("experiment_path", None),
-            forecast_granularity=d.get("forecast_granularity", None),
-            forecast_horizon=d.get("forecast_horizon", None),
-            future_feature_data_path=d.get("future_feature_data_path", None),
-            holiday_regions=d.get("holiday_regions", None),
-            include_features=d.get("include_features", None),
-            max_runtime=d.get("max_runtime", None),
-            prediction_data_path=d.get("prediction_data_path", None),
-            primary_metric=d.get("primary_metric", None),
-            register_to=d.get("register_to", None),
-            split_column=d.get("split_column", None),
-            target_column=d.get("target_column", None),
-            time_column=d.get("time_column", None),
-            timeseries_identifier_columns=d.get("timeseries_identifier_columns", None),
-            train_data_path=d.get("train_data_path", None),
-            training_frameworks=d.get("training_frameworks", None),
-        )
-
-
 @dataclass
 class CreateForecastingExperimentResponse:
     experiment_id: Optional[str] = None
@@ -682,73 +364,6 @@ class CreateForecastingExperimentResponse:
         return cls(experiment_id=d.get("experiment_id", None))
 
 
-@dataclass
-class CreateLoggedModelRequest:
-    experiment_id: str
-    """The ID of the experiment that owns the model."""
-
-    model_type: Optional[str] = None
-    """The type of the model, such as ``"Agent"``, ``"Classifier"``, ``"LLM"``."""
-
-    name: Optional[str] = None
-    """The name of the model (optional). If not specified one will be generated."""
-
-    params: Optional[List[LoggedModelParameter]] = None
-    """Parameters attached to the model."""
-
-    source_run_id: Optional[str] = None
-    """The ID of the run that created the model."""
-
-    tags: Optional[List[LoggedModelTag]] = None
-    """Tags attached to the model."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateLoggedModelRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.experiment_id is not None:
-            body["experiment_id"] = self.experiment_id
-        if self.model_type is not None:
-            body["model_type"] = self.model_type
-        if self.name is not None:
-            body["name"] = self.name
-        if self.params:
-            body["params"] = [v.as_dict() for v in self.params]
-        if self.source_run_id is not None:
-            body["source_run_id"] = self.source_run_id
-        if self.tags:
-            body["tags"] = [v.as_dict() for v in self.tags]
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateLoggedModelRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.experiment_id is not None:
-            body["experiment_id"] = self.experiment_id
-        if self.model_type is not None:
-            body["model_type"] = self.model_type
-        if self.name is not None:
-            body["name"] = self.name
-        if self.params:
-            body["params"] = self.params
-        if self.source_run_id is not None:
-            body["source_run_id"] = self.source_run_id
-        if self.tags:
-            body["tags"] = self.tags
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateLoggedModelRequest:
-        """Deserializes the CreateLoggedModelRequest from a dictionary."""
-        return cls(
-            experiment_id=d.get("experiment_id", None),
-            model_type=d.get("model_type", None),
-            name=d.get("name", None),
-            params=_repeated_dict(d, "params", LoggedModelParameter),
-            source_run_id=d.get("source_run_id", None),
-            tags=_repeated_dict(d, "tags", LoggedModelTag),
-        )
-
-
 @dataclass
 class CreateLoggedModelResponse:
     model: Optional[LoggedModel] = None
@@ -774,47 +389,6 @@ class CreateLoggedModelResponse:
         return cls(model=_from_dict(d, "model", LoggedModel))
 
 
-@dataclass
-class CreateModelRequest:
-    name: str
-    """Register models under this name"""
-
-    description: Optional[str] = None
-    """Optional description for registered model."""
-
-    tags: Optional[List[ModelTag]] = None
-    """Additional metadata for registered model."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateModelRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.description is not None:
-            body["description"] = self.description
-        if self.name is not None:
-            body["name"] = self.name
-        if self.tags:
-            body["tags"] = [v.as_dict() for v in self.tags]
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateModelRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.description is not None:
-            body["description"] = self.description
-        if self.name is not None:
-            body["name"] = self.name
-        if self.tags:
-            body["tags"] = self.tags
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateModelRequest:
-        """Deserializes the CreateModelRequest from a dictionary."""
-        return cls(
-            description=d.get("description", None), name=d.get("name", None), tags=_repeated_dict(d, "tags", ModelTag)
-        )
-
-
 @dataclass
 class CreateModelResponse:
     registered_model: Optional[Model] = None
@@ -840,81 +414,12 @@ class CreateModelResponse:
 
 
 @dataclass
-class CreateModelVersionRequest:
-    name: str
-    """Register model under this name"""
-
-    source: str
-    """URI indicating the location of the model artifacts."""
-
-    description: Optional[str] = None
-    """Optional description for model version."""
-
-    run_id: Optional[str] = None
-    """MLflow run ID for correlation, if `source` was generated by an experiment run in MLflow tracking
-    server"""
-
-    run_link: Optional[str] = None
-    """MLflow run link - this is the exact link of the run that generated this model version,
-    potentially hosted at another instance of MLflow."""
-
-    tags: Optional[List[ModelVersionTag]] = None
-    """Additional metadata for model version."""
+class CreateModelVersionResponse:
+    model_version: Optional[ModelVersion] = None
+    """Return new version number generated for this model in registry."""
 
     def as_dict(self) -> dict:
-        """Serializes the CreateModelVersionRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.description is not None:
-            body["description"] = self.description
-        if self.name is not None:
-            body["name"] = self.name
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        if self.run_link is not None:
-            body["run_link"] = self.run_link
-        if self.source is not None:
-            body["source"] = self.source
-        if self.tags:
-            body["tags"] = [v.as_dict() for v in self.tags]
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateModelVersionRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.description is not None:
-            body["description"] = self.description
-        if self.name is not None:
-            body["name"] = self.name
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        if self.run_link is not None:
-            body["run_link"] = self.run_link
-        if self.source is not None:
-            body["source"] = self.source
-        if self.tags:
-            body["tags"] = self.tags
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateModelVersionRequest:
-        """Deserializes the CreateModelVersionRequest from a dictionary."""
-        return cls(
-            description=d.get("description", None),
-            name=d.get("name", None),
-            run_id=d.get("run_id", None),
-            run_link=d.get("run_link", None),
-            source=d.get("source", None),
-            tags=_repeated_dict(d, "tags", ModelVersionTag),
-        )
-
-
-@dataclass
-class CreateModelVersionResponse:
-    model_version: Optional[ModelVersion] = None
-    """Return new version number generated for this model in registry."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateModelVersionResponse into a dictionary suitable for use as a JSON request body."""
+        """Serializes the CreateModelVersionResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.model_version:
             body["model_version"] = self.model_version.as_dict()
@@ -933,165 +438,6 @@ class CreateModelVersionResponse:
         return cls(model_version=_from_dict(d, "model_version", ModelVersion))
 
 
-@dataclass
-class CreateRegistryWebhook:
-    events: List[RegistryWebhookEvent]
-    """Events that can trigger a registry webhook: * `MODEL_VERSION_CREATED`: A new model version was
-    created for the associated model.
-    
-    * `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."""
-
-    description: Optional[str] = None
-    """User-specified description for the webhook."""
-
-    http_url_spec: Optional[HttpUrlSpec] = None
-
-    job_spec: Optional[JobSpec] = None
-
-    model_name: Optional[str] = None
-    """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."""
-
-    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 CreateRegistryWebhook into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.description is not None:
-            body["description"] = self.description
-        if self.events:
-            body["events"] = [v.value for v in self.events]
-        if self.http_url_spec:
-            body["http_url_spec"] = self.http_url_spec.as_dict()
-        if self.job_spec:
-            body["job_spec"] = self.job_spec.as_dict()
-        if self.model_name is not None:
-            body["model_name"] = self.model_name
-        if self.status is not None:
-            body["status"] = self.status.value
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateRegistryWebhook into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.description is not None:
-            body["description"] = self.description
-        if self.events:
-            body["events"] = self.events
-        if self.http_url_spec:
-            body["http_url_spec"] = self.http_url_spec
-        if self.job_spec:
-            body["job_spec"] = self.job_spec
-        if self.model_name is not None:
-            body["model_name"] = self.model_name
-        if self.status is not None:
-            body["status"] = self.status
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateRegistryWebhook:
-        """Deserializes the CreateRegistryWebhook from a dictionary."""
-        return cls(
-            description=d.get("description", None),
-            events=_repeated_enum(d, "events", RegistryWebhookEvent),
-            http_url_spec=_from_dict(d, "http_url_spec", HttpUrlSpec),
-            job_spec=_from_dict(d, "job_spec", JobSpec),
-            model_name=d.get("model_name", None),
-            status=_enum(d, "status", RegistryWebhookStatus),
-        )
-
-
-@dataclass
-class CreateRun:
-    experiment_id: Optional[str] = None
-    """ID of the associated experiment."""
-
-    run_name: Optional[str] = None
-    """The name of the run."""
-
-    start_time: Optional[int] = None
-    """Unix timestamp in milliseconds of when the run started."""
-
-    tags: Optional[List[RunTag]] = None
-    """Additional metadata for run."""
-
-    user_id: Optional[str] = None
-    """ID of the user executing the run. This field is deprecated as of MLflow 1.0, and will be removed
-    in a future MLflow release. Use 'mlflow.user' tag instead."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateRun into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.experiment_id is not None:
-            body["experiment_id"] = self.experiment_id
-        if self.run_name is not None:
-            body["run_name"] = self.run_name
-        if self.start_time is not None:
-            body["start_time"] = self.start_time
-        if self.tags:
-            body["tags"] = [v.as_dict() for v in self.tags]
-        if self.user_id is not None:
-            body["user_id"] = self.user_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateRun into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.experiment_id is not None:
-            body["experiment_id"] = self.experiment_id
-        if self.run_name is not None:
-            body["run_name"] = self.run_name
-        if self.start_time is not None:
-            body["start_time"] = self.start_time
-        if self.tags:
-            body["tags"] = self.tags
-        if self.user_id is not None:
-            body["user_id"] = self.user_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateRun:
-        """Deserializes the CreateRun from a dictionary."""
-        return cls(
-            experiment_id=d.get("experiment_id", None),
-            run_name=d.get("run_name", None),
-            start_time=d.get("start_time", None),
-            tags=_repeated_dict(d, "tags", RunTag),
-            user_id=d.get("user_id", None),
-        )
-
-
 @dataclass
 class CreateRunResponse:
     run: Optional[Run] = None
@@ -1117,69 +463,10 @@ class CreateRunResponse:
         return cls(run=_from_dict(d, "run", Run))
 
 
-@dataclass
-class CreateTransitionRequest:
-    name: str
-    """Name of the model."""
-
-    version: str
-    """Version of the model."""
-
-    stage: Stage
-    """Target stage of the transition. Valid values are:
-    
-    * `None`: The initial stage of a model version.
-    
-    * `Staging`: Staging or pre-production stage.
-    
-    * `Production`: Production stage.
-    
-    * `Archived`: Archived stage."""
-
-    comment: Optional[str] = None
-    """User-provided comment on the action."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateTransitionRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.comment is not None:
-            body["comment"] = self.comment
-        if self.name is not None:
-            body["name"] = self.name
-        if self.stage is not None:
-            body["stage"] = self.stage.value
-        if self.version is not None:
-            body["version"] = self.version
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateTransitionRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.comment is not None:
-            body["comment"] = self.comment
-        if self.name is not None:
-            body["name"] = self.name
-        if self.stage is not None:
-            body["stage"] = self.stage
-        if self.version is not None:
-            body["version"] = self.version
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateTransitionRequest:
-        """Deserializes the CreateTransitionRequest from a dictionary."""
-        return cls(
-            comment=d.get("comment", None),
-            name=d.get("name", None),
-            stage=_enum(d, "stage", Stage),
-            version=d.get("version", None),
-        )
-
-
 @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."""
@@ -1351,31 +638,6 @@ class DeleteCommentResponse:
         return cls()
 
 
-@dataclass
-class DeleteExperiment:
-    experiment_id: str
-    """ID of the associated experiment."""
-
-    def as_dict(self) -> dict:
-        """Serializes the DeleteExperiment into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.experiment_id is not None:
-            body["experiment_id"] = self.experiment_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DeleteExperiment into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.experiment_id is not None:
-            body["experiment_id"] = self.experiment_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DeleteExperiment:
-        """Deserializes the DeleteExperiment from a dictionary."""
-        return cls(experiment_id=d.get("experiment_id", None))
-
-
 @dataclass
 class DeleteExperimentResponse:
     def as_dict(self) -> dict:
@@ -1503,125 +765,37 @@ class DeleteModelVersionTagResponse:
 
 
 @dataclass
-class DeleteOnlineStoreResponse:
+class DeleteRunResponse:
     def as_dict(self) -> dict:
-        """Serializes the DeleteOnlineStoreResponse into a dictionary suitable for use as a JSON request body."""
+        """Serializes the DeleteRunResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the DeleteOnlineStoreResponse into a shallow dictionary of its immediate attributes."""
+        """Serializes the DeleteRunResponse into a shallow dictionary of its immediate attributes."""
         body = {}
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DeleteOnlineStoreResponse:
-        """Deserializes the DeleteOnlineStoreResponse from a dictionary."""
+    def from_dict(cls, d: Dict[str, Any]) -> DeleteRunResponse:
+        """Deserializes the DeleteRunResponse from a dictionary."""
         return cls()
 
 
 @dataclass
-class DeleteRun:
-    run_id: str
-    """ID of the run to delete."""
+class DeleteRunsResponse:
+    runs_deleted: Optional[int] = None
+    """The number of runs deleted."""
 
     def as_dict(self) -> dict:
-        """Serializes the DeleteRun into a dictionary suitable for use as a JSON request body."""
+        """Serializes the DeleteRunsResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
+        if self.runs_deleted is not None:
+            body["runs_deleted"] = self.runs_deleted
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the DeleteRun into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DeleteRun:
-        """Deserializes the DeleteRun from a dictionary."""
-        return cls(run_id=d.get("run_id", None))
-
-
-@dataclass
-class DeleteRunResponse:
-    def as_dict(self) -> dict:
-        """Serializes the DeleteRunResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DeleteRunResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DeleteRunResponse:
-        """Deserializes the DeleteRunResponse from a dictionary."""
-        return cls()
-
-
-@dataclass
-class DeleteRuns:
-    experiment_id: str
-    """The ID of the experiment containing the runs to delete."""
-
-    max_timestamp_millis: int
-    """The maximum creation timestamp in milliseconds since the UNIX epoch for deleting runs. Only runs
-    created prior to or at this timestamp are deleted."""
-
-    max_runs: Optional[int] = None
-    """An optional positive integer indicating the maximum number of runs to delete. The maximum
-    allowed value for max_runs is 10000."""
-
-    def as_dict(self) -> dict:
-        """Serializes the DeleteRuns into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.experiment_id is not None:
-            body["experiment_id"] = self.experiment_id
-        if self.max_runs is not None:
-            body["max_runs"] = self.max_runs
-        if self.max_timestamp_millis is not None:
-            body["max_timestamp_millis"] = self.max_timestamp_millis
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DeleteRuns into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.experiment_id is not None:
-            body["experiment_id"] = self.experiment_id
-        if self.max_runs is not None:
-            body["max_runs"] = self.max_runs
-        if self.max_timestamp_millis is not None:
-            body["max_timestamp_millis"] = self.max_timestamp_millis
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DeleteRuns:
-        """Deserializes the DeleteRuns from a dictionary."""
-        return cls(
-            experiment_id=d.get("experiment_id", None),
-            max_runs=d.get("max_runs", None),
-            max_timestamp_millis=d.get("max_timestamp_millis", None),
-        )
-
-
-@dataclass
-class DeleteRunsResponse:
-    runs_deleted: Optional[int] = None
-    """The number of runs deleted."""
-
-    def as_dict(self) -> dict:
-        """Serializes the DeleteRunsResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.runs_deleted is not None:
-            body["runs_deleted"] = self.runs_deleted
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DeleteRunsResponse into a shallow dictionary of its immediate attributes."""
+        """Serializes the DeleteRunsResponse into a shallow dictionary of its immediate attributes."""
         body = {}
         if self.runs_deleted is not None:
             body["runs_deleted"] = self.runs_deleted
@@ -1633,38 +807,6 @@ class DeleteRunsResponse:
         return cls(runs_deleted=d.get("runs_deleted", None))
 
 
-@dataclass
-class DeleteTag:
-    run_id: str
-    """ID of the run that the tag was logged under. Must be provided."""
-
-    key: str
-    """Name of the tag. Maximum size is 255 bytes. Must be provided."""
-
-    def as_dict(self) -> dict:
-        """Serializes the DeleteTag into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.key is not None:
-            body["key"] = self.key
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DeleteTag into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.key is not None:
-            body["key"] = self.key
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DeleteTag:
-        """Deserializes the DeleteTag from a dictionary."""
-        return cls(key=d.get("key", None), run_id=d.get("run_id", None))
-
-
 @dataclass
 class DeleteTagResponse:
     def as_dict(self) -> dict:
@@ -1685,28 +827,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
@@ -1811,7 +952,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"""
@@ -1922,7 +1062,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."""
@@ -2009,7 +1148,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."""
@@ -2038,40 +1176,6 @@ class ExperimentPermissionsDescription:
         )
 
 
-@dataclass
-class ExperimentPermissionsRequest:
-    access_control_list: Optional[List[ExperimentAccessControlRequest]] = None
-
-    experiment_id: Optional[str] = None
-    """The experiment for which to get or manage permissions."""
-
-    def as_dict(self) -> dict:
-        """Serializes the ExperimentPermissionsRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = [v.as_dict() for v in self.access_control_list]
-        if self.experiment_id is not None:
-            body["experiment_id"] = self.experiment_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the ExperimentPermissionsRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = self.access_control_list
-        if self.experiment_id is not None:
-            body["experiment_id"] = self.experiment_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> ExperimentPermissionsRequest:
-        """Deserializes the ExperimentPermissionsRequest from a dictionary."""
-        return cls(
-            access_control_list=_repeated_dict(d, "access_control_list", ExperimentAccessControlRequest),
-            experiment_id=d.get("experiment_id", None),
-        )
-
-
 @dataclass
 class ExperimentTag:
     """A tag for an experiment."""
@@ -2107,263 +1211,433 @@ class ExperimentTag:
 
 
 @dataclass
-class FileInfo:
-    """Metadata of a single artifact file or directory."""
+class Feature:
+    """Feature for model version."""
 
-    file_size: Optional[int] = None
-    """The size in bytes of the file. Unset for directories."""
+    feature_name: Optional[str] = None
+    """Feature name"""
 
-    is_dir: Optional[bool] = None
-    """Whether the path is a directory."""
+    feature_table_id: Optional[str] = None
+    """Feature table id"""
 
-    path: Optional[str] = None
-    """The path relative to the root artifact directory run."""
+    feature_table_name: Optional[str] = None
+    """Feature table name"""
 
     def as_dict(self) -> dict:
-        """Serializes the FileInfo into a dictionary suitable for use as a JSON request body."""
+        """Serializes the Feature into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.file_size is not None:
-            body["file_size"] = self.file_size
-        if self.is_dir is not None:
-            body["is_dir"] = self.is_dir
-        if self.path is not None:
-            body["path"] = self.path
+        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 FileInfo into a shallow dictionary of its immediate attributes."""
+        """Serializes the Feature into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.file_size is not None:
-            body["file_size"] = self.file_size
-        if self.is_dir is not None:
-            body["is_dir"] = self.is_dir
-        if self.path is not None:
-            body["path"] = self.path
+        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]) -> FileInfo:
-        """Deserializes the FileInfo from a dictionary."""
-        return cls(file_size=d.get("file_size", None), is_dir=d.get("is_dir", None), path=d.get("path", None))
+    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 FinalizeLoggedModelRequest:
-    status: LoggedModelStatus
-    """Whether or not the model is ready for use. ``"LOGGED_MODEL_UPLOAD_FAILED"`` indicates that
-    something went wrong when logging the model weights / agent code."""
+class FeatureLineage:
+    feature_specs: Optional[List[FeatureLineageFeatureSpec]] = None
+    """List of feature specs that contain this feature."""
 
-    model_id: Optional[str] = None
-    """The ID of the logged model to finalize."""
+    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 FinalizeLoggedModelRequest into a dictionary suitable for use as a JSON request body."""
+        """Serializes the FeatureLineage into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.model_id is not None:
-            body["model_id"] = self.model_id
-        if self.status is not None:
-            body["status"] = self.status.value
+        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 FinalizeLoggedModelRequest into a shallow dictionary of its immediate attributes."""
+        """Serializes the FeatureLineage into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.model_id is not None:
-            body["model_id"] = self.model_id
-        if self.status is not None:
-            body["status"] = self.status
+        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]) -> FinalizeLoggedModelRequest:
-        """Deserializes the FinalizeLoggedModelRequest from a dictionary."""
-        return cls(model_id=d.get("model_id", None), status=_enum(d, "status", LoggedModelStatus))
+    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 FinalizeLoggedModelResponse:
-    model: Optional[LoggedModel] = None
-    """The updated logged model."""
+class FeatureLineageFeatureSpec:
+    name: Optional[str] = None
+    """The full name of the feature spec in Unity Catalog."""
 
     def as_dict(self) -> dict:
-        """Serializes the FinalizeLoggedModelResponse into a dictionary suitable for use as a JSON request body."""
+        """Serializes the FeatureLineageFeatureSpec into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.model:
-            body["model"] = self.model.as_dict()
+        if self.name is not None:
+            body["name"] = self.name
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the FinalizeLoggedModelResponse into a shallow dictionary of its immediate attributes."""
+        """Serializes the FeatureLineageFeatureSpec into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.model:
-            body["model"] = self.model
+        if self.name is not None:
+            body["name"] = self.name
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> FinalizeLoggedModelResponse:
-        """Deserializes the FinalizeLoggedModelResponse from a dictionary."""
-        return cls(model=_from_dict(d, "model", LoggedModel))
+    def from_dict(cls, d: Dict[str, Any]) -> FeatureLineageFeatureSpec:
+        """Deserializes the FeatureLineageFeatureSpec from a dictionary."""
+        return cls(name=d.get("name", None))
 
 
 @dataclass
-class ForecastingExperiment:
-    """Represents a forecasting experiment with its unique identifier, URL, and state."""
-
-    experiment_id: Optional[str] = None
-    """The unique ID for the forecasting experiment."""
-
-    experiment_page_url: Optional[str] = None
-    """The URL to the forecasting experiment page."""
+class FeatureLineageModel:
+    name: Optional[str] = None
+    """The full name of the model in Unity Catalog."""
 
-    state: Optional[ForecastingExperimentState] = None
-    """The current state of the forecasting experiment."""
+    version: Optional[int] = None
+    """The version of the model."""
 
     def as_dict(self) -> dict:
-        """Serializes the ForecastingExperiment into a dictionary suitable for use as a JSON request body."""
+        """Serializes the FeatureLineageModel into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.experiment_id is not None:
-            body["experiment_id"] = self.experiment_id
-        if self.experiment_page_url is not None:
-            body["experiment_page_url"] = self.experiment_page_url
-        if self.state is not None:
-            body["state"] = self.state.value
+        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 ForecastingExperiment into a shallow dictionary of its immediate attributes."""
+        """Serializes the FeatureLineageModel into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.experiment_id is not None:
-            body["experiment_id"] = self.experiment_id
-        if self.experiment_page_url is not None:
-            body["experiment_page_url"] = self.experiment_page_url
-        if self.state is not None:
-            body["state"] = self.state
+        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]) -> ForecastingExperiment:
-        """Deserializes the ForecastingExperiment from a dictionary."""
-        return cls(
-            experiment_id=d.get("experiment_id", None),
-            experiment_page_url=d.get("experiment_page_url", None),
-            state=_enum(d, "state", ForecastingExperimentState),
-        )
-
-
-class ForecastingExperimentState(Enum):
-
-    CANCELLED = "CANCELLED"
-    FAILED = "FAILED"
-    PENDING = "PENDING"
-    RUNNING = "RUNNING"
-    SUCCEEDED = "SUCCEEDED"
+    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 GetExperimentByNameResponse:
-    experiment: Optional[Experiment] = None
-    """Experiment details."""
+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 GetExperimentByNameResponse into a dictionary suitable for use as a JSON request body."""
+        """Serializes the FeatureLineageOnlineFeature into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.experiment:
-            body["experiment"] = self.experiment.as_dict()
+        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 GetExperimentByNameResponse into a shallow dictionary of its immediate attributes."""
+        """Serializes the FeatureLineageOnlineFeature into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.experiment:
-            body["experiment"] = self.experiment
+        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]) -> GetExperimentByNameResponse:
-        """Deserializes the GetExperimentByNameResponse from a dictionary."""
-        return cls(experiment=_from_dict(d, "experiment", Experiment))
+    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 GetExperimentPermissionLevelsResponse:
-    permission_levels: Optional[List[ExperimentPermissionsDescription]] = None
-    """Specific permission levels"""
+class FeatureList:
+    """Feature list wrap all the features for a model version"""
+
+    features: Optional[List[Feature]] = None
 
     def as_dict(self) -> dict:
-        """Serializes the GetExperimentPermissionLevelsResponse into a dictionary suitable for use as a JSON request body."""
+        """Serializes the FeatureList into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.permission_levels:
-            body["permission_levels"] = [v.as_dict() for v in self.permission_levels]
+        if self.features:
+            body["features"] = [v.as_dict() for v in self.features]
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the GetExperimentPermissionLevelsResponse into a shallow dictionary of its immediate attributes."""
+        """Serializes the FeatureList into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.permission_levels:
-            body["permission_levels"] = self.permission_levels
+        if self.features:
+            body["features"] = self.features
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> GetExperimentPermissionLevelsResponse:
-        """Deserializes the GetExperimentPermissionLevelsResponse from a dictionary."""
-        return cls(permission_levels=_repeated_dict(d, "permission_levels", ExperimentPermissionsDescription))
+    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 GetExperimentResponse:
+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."""
+
+    file_size: Optional[int] = None
+    """The size in bytes of the file. Unset for directories."""
+
+    is_dir: Optional[bool] = None
+    """Whether the path is a directory."""
+
+    path: Optional[str] = None
+    """The path relative to the root artifact directory run."""
+
+    def as_dict(self) -> dict:
+        """Serializes the FileInfo into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.file_size is not None:
+            body["file_size"] = self.file_size
+        if self.is_dir is not None:
+            body["is_dir"] = self.is_dir
+        if self.path is not None:
+            body["path"] = self.path
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the FileInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.file_size is not None:
+            body["file_size"] = self.file_size
+        if self.is_dir is not None:
+            body["is_dir"] = self.is_dir
+        if self.path is not None:
+            body["path"] = self.path
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> FileInfo:
+        """Deserializes the FileInfo from a dictionary."""
+        return cls(file_size=d.get("file_size", None), is_dir=d.get("is_dir", None), path=d.get("path", None))
+
+
+@dataclass
+class FinalizeLoggedModelResponse:
+    model: Optional[LoggedModel] = None
+    """The updated logged model."""
+
+    def as_dict(self) -> dict:
+        """Serializes the FinalizeLoggedModelResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.model:
+            body["model"] = self.model.as_dict()
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the FinalizeLoggedModelResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.model:
+            body["model"] = self.model
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> FinalizeLoggedModelResponse:
+        """Deserializes the FinalizeLoggedModelResponse from a dictionary."""
+        return cls(model=_from_dict(d, "model", LoggedModel))
+
+
+@dataclass
+class ForecastingExperiment:
+    """Represents a forecasting experiment with its unique identifier, URL, and state."""
+
+    experiment_id: Optional[str] = None
+    """The unique ID for the forecasting experiment."""
+
+    experiment_page_url: Optional[str] = None
+    """The URL to the forecasting experiment page."""
+
+    state: Optional[ForecastingExperimentState] = None
+    """The current state of the forecasting experiment."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ForecastingExperiment into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.experiment_id is not None:
+            body["experiment_id"] = self.experiment_id
+        if self.experiment_page_url is not None:
+            body["experiment_page_url"] = self.experiment_page_url
+        if self.state is not None:
+            body["state"] = self.state.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ForecastingExperiment into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.experiment_id is not None:
+            body["experiment_id"] = self.experiment_id
+        if self.experiment_page_url is not None:
+            body["experiment_page_url"] = self.experiment_page_url
+        if self.state is not None:
+            body["state"] = self.state
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ForecastingExperiment:
+        """Deserializes the ForecastingExperiment from a dictionary."""
+        return cls(
+            experiment_id=d.get("experiment_id", None),
+            experiment_page_url=d.get("experiment_page_url", None),
+            state=_enum(d, "state", ForecastingExperimentState),
+        )
+
+
+class ForecastingExperimentState(Enum):
+
+    CANCELLED = "CANCELLED"
+    FAILED = "FAILED"
+    PENDING = "PENDING"
+    RUNNING = "RUNNING"
+    SUCCEEDED = "SUCCEEDED"
+
+
+@dataclass
+class GetExperimentByNameResponse:
     experiment: Optional[Experiment] = None
     """Experiment details."""
 
     def as_dict(self) -> dict:
-        """Serializes the GetExperimentResponse into a dictionary suitable for use as a JSON request body."""
+        """Serializes the GetExperimentByNameResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.experiment:
             body["experiment"] = self.experiment.as_dict()
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the GetExperimentResponse into a shallow dictionary of its immediate attributes."""
+        """Serializes the GetExperimentByNameResponse into a shallow dictionary of its immediate attributes."""
         body = {}
         if self.experiment:
             body["experiment"] = self.experiment
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> GetExperimentResponse:
-        """Deserializes the GetExperimentResponse from a dictionary."""
+    def from_dict(cls, d: Dict[str, Any]) -> GetExperimentByNameResponse:
+        """Deserializes the GetExperimentByNameResponse from a dictionary."""
         return cls(experiment=_from_dict(d, "experiment", Experiment))
 
 
 @dataclass
-class GetLatestVersionsRequest:
-    name: str
-    """Registered model unique name identifier."""
+class GetExperimentPermissionLevelsResponse:
+    permission_levels: Optional[List[ExperimentPermissionsDescription]] = None
+    """Specific permission levels"""
+
+    def as_dict(self) -> dict:
+        """Serializes the GetExperimentPermissionLevelsResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.permission_levels:
+            body["permission_levels"] = [v.as_dict() for v in self.permission_levels]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GetExperimentPermissionLevelsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.permission_levels:
+            body["permission_levels"] = self.permission_levels
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> GetExperimentPermissionLevelsResponse:
+        """Deserializes the GetExperimentPermissionLevelsResponse from a dictionary."""
+        return cls(permission_levels=_repeated_dict(d, "permission_levels", ExperimentPermissionsDescription))
+
 
-    stages: Optional[List[str]] = None
-    """List of stages."""
+@dataclass
+class GetExperimentResponse:
+    experiment: Optional[Experiment] = None
+    """Experiment details."""
 
     def as_dict(self) -> dict:
-        """Serializes the GetLatestVersionsRequest into a dictionary suitable for use as a JSON request body."""
+        """Serializes the GetExperimentResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.name is not None:
-            body["name"] = self.name
-        if self.stages:
-            body["stages"] = [v for v in self.stages]
+        if self.experiment:
+            body["experiment"] = self.experiment.as_dict()
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the GetLatestVersionsRequest into a shallow dictionary of its immediate attributes."""
+        """Serializes the GetExperimentResponse into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.name is not None:
-            body["name"] = self.name
-        if self.stages:
-            body["stages"] = self.stages
+        if self.experiment:
+            body["experiment"] = self.experiment
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> GetLatestVersionsRequest:
-        """Deserializes the GetLatestVersionsRequest from a dictionary."""
-        return cls(name=d.get("name", None), stages=d.get("stages", None))
+    def from_dict(cls, d: Dict[str, Any]) -> GetExperimentResponse:
+        """Deserializes the GetExperimentResponse from a dictionary."""
+        return cls(experiment=_from_dict(d, "experiment", Experiment))
 
 
 @dataclass
@@ -2753,9 +2027,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."""
@@ -2859,6 +2132,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
@@ -2988,129 +2296,32 @@ class ListTransitionRequestsResponse:
 
 
 @dataclass
-class LogBatch:
-    metrics: Optional[List[Metric]] = None
-    """Metrics to log. A single request can contain up to 1000 metrics, and up to 1000 metrics, params,
-    and tags in total."""
+class LogBatchResponse:
+    def as_dict(self) -> dict:
+        """Serializes the LogBatchResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        return body
 
-    params: Optional[List[Param]] = None
-    """Params to log. A single request can contain up to 100 params, and up to 1000 metrics, params,
-    and tags in total."""
+    def as_shallow_dict(self) -> dict:
+        """Serializes the LogBatchResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
 
-    run_id: Optional[str] = None
-    """ID of the run to log under"""
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> LogBatchResponse:
+        """Deserializes the LogBatchResponse from a dictionary."""
+        return cls()
 
-    tags: Optional[List[RunTag]] = None
-    """Tags to log. A single request can contain up to 100 tags, and up to 1000 metrics, params, and
-    tags in total."""
 
+@dataclass
+class LogInputsResponse:
     def as_dict(self) -> dict:
-        """Serializes the LogBatch into a dictionary suitable for use as a JSON request body."""
+        """Serializes the LogInputsResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.metrics:
-            body["metrics"] = [v.as_dict() for v in self.metrics]
-        if self.params:
-            body["params"] = [v.as_dict() for v in self.params]
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        if self.tags:
-            body["tags"] = [v.as_dict() for v in self.tags]
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the LogBatch into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.metrics:
-            body["metrics"] = self.metrics
-        if self.params:
-            body["params"] = self.params
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        if self.tags:
-            body["tags"] = self.tags
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> LogBatch:
-        """Deserializes the LogBatch from a dictionary."""
-        return cls(
-            metrics=_repeated_dict(d, "metrics", Metric),
-            params=_repeated_dict(d, "params", Param),
-            run_id=d.get("run_id", None),
-            tags=_repeated_dict(d, "tags", RunTag),
-        )
-
-
-@dataclass
-class LogBatchResponse:
-    def as_dict(self) -> dict:
-        """Serializes the LogBatchResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the LogBatchResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> LogBatchResponse:
-        """Deserializes the LogBatchResponse from a dictionary."""
-        return cls()
-
-
-@dataclass
-class LogInputs:
-    run_id: str
-    """ID of the run to log under"""
-
-    datasets: Optional[List[DatasetInput]] = None
-    """Dataset inputs"""
-
-    models: Optional[List[ModelInput]] = None
-    """Model inputs"""
-
-    def as_dict(self) -> dict:
-        """Serializes the LogInputs into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.datasets:
-            body["datasets"] = [v.as_dict() for v in self.datasets]
-        if self.models:
-            body["models"] = [v.as_dict() for v in self.models]
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the LogInputs into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.datasets:
-            body["datasets"] = self.datasets
-        if self.models:
-            body["models"] = self.models
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> LogInputs:
-        """Deserializes the LogInputs from a dictionary."""
-        return cls(
-            datasets=_repeated_dict(d, "datasets", DatasetInput),
-            models=_repeated_dict(d, "models", ModelInput),
-            run_id=d.get("run_id", None),
-        )
-
-
-@dataclass
-class LogInputsResponse:
-    def as_dict(self) -> dict:
-        """Serializes the LogInputsResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the LogInputsResponse into a shallow dictionary of its immediate attributes."""
+        """Serializes the LogInputsResponse into a shallow dictionary of its immediate attributes."""
         body = {}
         return body
 
@@ -3120,38 +2331,6 @@ class LogInputsResponse:
         return cls()
 
 
-@dataclass
-class LogLoggedModelParamsRequest:
-    model_id: Optional[str] = None
-    """The ID of the logged model to log params for."""
-
-    params: Optional[List[LoggedModelParameter]] = None
-    """Parameters to attach to the model."""
-
-    def as_dict(self) -> dict:
-        """Serializes the LogLoggedModelParamsRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.model_id is not None:
-            body["model_id"] = self.model_id
-        if self.params:
-            body["params"] = [v.as_dict() for v in self.params]
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the LogLoggedModelParamsRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.model_id is not None:
-            body["model_id"] = self.model_id
-        if self.params:
-            body["params"] = self.params
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> LogLoggedModelParamsRequest:
-        """Deserializes the LogLoggedModelParamsRequest from a dictionary."""
-        return cls(model_id=d.get("model_id", None), params=_repeated_dict(d, "params", LoggedModelParameter))
-
-
 @dataclass
 class LogLoggedModelParamsRequestResponse:
     def as_dict(self) -> dict:
@@ -3170,100 +2349,6 @@ class LogLoggedModelParamsRequestResponse:
         return cls()
 
 
-@dataclass
-class LogMetric:
-    key: str
-    """Name of the metric."""
-
-    value: float
-    """Double value of the metric being logged."""
-
-    timestamp: int
-    """Unix timestamp in milliseconds at the time metric was logged."""
-
-    dataset_digest: Optional[str] = None
-    """Dataset digest of the dataset associated with the metric, e.g. an md5 hash of the dataset that
-    uniquely identifies it within datasets of the same name."""
-
-    dataset_name: Optional[str] = None
-    """The name of the dataset associated with the metric. E.g. “my.uc.table@2”
-    “nyc-taxi-dataset”, “fantastic-elk-3”"""
-
-    model_id: Optional[str] = None
-    """ID of the logged model associated with the metric, if applicable"""
-
-    run_id: Optional[str] = None
-    """ID of the run under which to log the metric. Must be provided."""
-
-    run_uuid: Optional[str] = None
-    """[Deprecated, use `run_id` instead] ID of the run under which to log the metric. This field will
-    be removed in a future MLflow version."""
-
-    step: Optional[int] = None
-    """Step at which to log the metric"""
-
-    def as_dict(self) -> dict:
-        """Serializes the LogMetric into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.dataset_digest is not None:
-            body["dataset_digest"] = self.dataset_digest
-        if self.dataset_name is not None:
-            body["dataset_name"] = self.dataset_name
-        if self.key is not None:
-            body["key"] = self.key
-        if self.model_id is not None:
-            body["model_id"] = self.model_id
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        if self.run_uuid is not None:
-            body["run_uuid"] = self.run_uuid
-        if self.step is not None:
-            body["step"] = self.step
-        if self.timestamp is not None:
-            body["timestamp"] = self.timestamp
-        if self.value is not None:
-            body["value"] = self.value
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the LogMetric into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.dataset_digest is not None:
-            body["dataset_digest"] = self.dataset_digest
-        if self.dataset_name is not None:
-            body["dataset_name"] = self.dataset_name
-        if self.key is not None:
-            body["key"] = self.key
-        if self.model_id is not None:
-            body["model_id"] = self.model_id
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        if self.run_uuid is not None:
-            body["run_uuid"] = self.run_uuid
-        if self.step is not None:
-            body["step"] = self.step
-        if self.timestamp is not None:
-            body["timestamp"] = self.timestamp
-        if self.value is not None:
-            body["value"] = self.value
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> LogMetric:
-        """Deserializes the LogMetric from a dictionary."""
-        return cls(
-            dataset_digest=d.get("dataset_digest", None),
-            dataset_name=d.get("dataset_name", None),
-            key=d.get("key", None),
-            model_id=d.get("model_id", None),
-            run_id=d.get("run_id", None),
-            run_uuid=d.get("run_uuid", None),
-            step=d.get("step", None),
-            timestamp=d.get("timestamp", None),
-            value=d.get("value", None),
-        )
-
-
 @dataclass
 class LogMetricResponse:
     def as_dict(self) -> dict:
@@ -3282,38 +2367,6 @@ class LogMetricResponse:
         return cls()
 
 
-@dataclass
-class LogModel:
-    model_json: Optional[str] = None
-    """MLmodel file in json format."""
-
-    run_id: Optional[str] = None
-    """ID of the run to log under"""
-
-    def as_dict(self) -> dict:
-        """Serializes the LogModel into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.model_json is not None:
-            body["model_json"] = self.model_json
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the LogModel into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.model_json is not None:
-            body["model_json"] = self.model_json
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> LogModel:
-        """Deserializes the LogModel from a dictionary."""
-        return cls(model_json=d.get("model_json", None), run_id=d.get("run_id", None))
-
-
 @dataclass
 class LogModelResponse:
     def as_dict(self) -> dict:
@@ -3332,38 +2385,6 @@ class LogModelResponse:
         return cls()
 
 
-@dataclass
-class LogOutputsRequest:
-    run_id: str
-    """The ID of the Run from which to log outputs."""
-
-    models: Optional[List[ModelOutput]] = None
-    """The model outputs from the Run."""
-
-    def as_dict(self) -> dict:
-        """Serializes the LogOutputsRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.models:
-            body["models"] = [v.as_dict() for v in self.models]
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the LogOutputsRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.models:
-            body["models"] = self.models
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> LogOutputsRequest:
-        """Deserializes the LogOutputsRequest from a dictionary."""
-        return cls(models=_repeated_dict(d, "models", ModelOutput), run_id=d.get("run_id", None))
-
-
 @dataclass
 class LogOutputsResponse:
     def as_dict(self) -> dict:
@@ -3382,58 +2403,6 @@ class LogOutputsResponse:
         return cls()
 
 
-@dataclass
-class LogParam:
-    key: str
-    """Name of the param. Maximum size is 255 bytes."""
-
-    value: str
-    """String value of the param being logged. Maximum size is 500 bytes."""
-
-    run_id: Optional[str] = None
-    """ID of the run under which to log the param. Must be provided."""
-
-    run_uuid: Optional[str] = None
-    """[Deprecated, use `run_id` instead] ID of the run under which to log the param. This field will
-    be removed in a future MLflow version."""
-
-    def as_dict(self) -> dict:
-        """Serializes the LogParam into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.key is not None:
-            body["key"] = self.key
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        if self.run_uuid is not None:
-            body["run_uuid"] = self.run_uuid
-        if self.value is not None:
-            body["value"] = self.value
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the LogParam into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.key is not None:
-            body["key"] = self.key
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        if self.run_uuid is not None:
-            body["run_uuid"] = self.run_uuid
-        if self.value is not None:
-            body["value"] = self.value
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> LogParam:
-        """Deserializes the LogParam from a dictionary."""
-        return cls(
-            key=d.get("key", None),
-            run_id=d.get("run_id", None),
-            run_uuid=d.get("run_uuid", None),
-            value=d.get("value", None),
-        )
-
-
 @dataclass
 class LogParamResponse:
     def as_dict(self) -> dict:
@@ -3892,7 +2861,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."""
@@ -3901,8 +2870,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."""
@@ -4035,6 +3003,8 @@ class ModelOutput:
 
 @dataclass
 class ModelTag:
+    """Tag for a registered model"""
+
     key: Optional[str] = None
     """The tag key."""
 
@@ -4194,29 +3164,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."""
@@ -4231,12 +3201,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."""
@@ -4256,13 +3220,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:
@@ -4292,10 +3262,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:
@@ -4321,10 +3297,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),
@@ -4338,7 +3317,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"
@@ -4384,7 +3368,7 @@ class OnlineStore:
     name: str
     """The name of the online store. This is the unique identifier for the online store."""
 
-    capacity: Optional[str] = None
+    capacity: str
     """The capacity of the online store. Valid values are "CU_1", "CU_2", "CU_4", "CU_8"."""
 
     creation_time: Optional[str] = None
@@ -4393,6 +3377,9 @@ class OnlineStore:
     creator: Optional[str] = None
     """The email of the creator of the online store."""
 
+    read_replica_count: Optional[int] = None
+    """The number of read replicas for the online store. Defaults to 0."""
+
     state: Optional[OnlineStoreState] = None
     """The current state of the online store."""
 
@@ -4407,6 +3394,8 @@ class OnlineStore:
             body["creator"] = self.creator
         if self.name is not None:
             body["name"] = self.name
+        if self.read_replica_count is not None:
+            body["read_replica_count"] = self.read_replica_count
         if self.state is not None:
             body["state"] = self.state.value
         return body
@@ -4422,6 +3411,8 @@ class OnlineStore:
             body["creator"] = self.creator
         if self.name is not None:
             body["name"] = self.name
+        if self.read_replica_count is not None:
+            body["read_replica_count"] = self.read_replica_count
         if self.state is not None:
             body["state"] = self.state
         return body
@@ -4434,6 +3425,7 @@ class OnlineStore:
             creation_time=d.get("creation_time", None),
             creator=d.get("creator", None),
             name=d.get("name", None),
+            read_replica_count=d.get("read_replica_count", None),
             state=_enum(d, "state", OnlineStoreState),
         )
 
@@ -4486,6 +3478,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"
@@ -4498,9 +3491,8 @@ class PublishSpec:
     online_store: str
     """The name of the target online store."""
 
-    online_table_name: Optional[str] = None
-    """The full three-part (catalog, schema, table) name of the online table. Auto-generated if not
-    specified."""
+    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
@@ -4545,40 +3537,6 @@ class PublishSpecPublishMode(Enum):
     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
@@ -4617,7 +3575,6 @@ class RegisteredModelAccessControlRequest:
     """name of the group"""
 
     permission_level: Optional[RegisteredModelPermissionLevel] = None
-    """Permission level"""
 
     service_principal_name: Optional[str] = None
     """application ID of a service principal"""
@@ -4728,7 +3685,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."""
@@ -4817,7 +3773,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."""
@@ -4846,38 +3801,16 @@ class RegisteredModelPermissionsDescription:
         )
 
 
-@dataclass
-class RegisteredModelPermissionsRequest:
-    access_control_list: Optional[List[RegisteredModelAccessControlRequest]] = None
-
-    registered_model_id: Optional[str] = None
-    """The registered model for which to get or manage permissions."""
-
-    def as_dict(self) -> dict:
-        """Serializes the RegisteredModelPermissionsRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = [v.as_dict() for v in self.access_control_list]
-        if self.registered_model_id is not None:
-            body["registered_model_id"] = self.registered_model_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the RegisteredModelPermissionsRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = self.access_control_list
-        if self.registered_model_id is not None:
-            body["registered_model_id"] = self.registered_model_id
-        return body
+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."""
 
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> RegisteredModelPermissionsRequest:
-        """Deserializes the RegisteredModelPermissionsRequest from a dictionary."""
-        return cls(
-            access_control_list=_repeated_dict(d, "access_control_list", RegisteredModelAccessControlRequest),
-            registered_model_id=d.get("registered_model_id", None),
-        )
+    ALL_EVENTS = "ALL_EVENTS"
+    DEFAULT = "DEFAULT"
+    SUBSCRIBED = "SUBSCRIBED"
+    UNSUBSCRIBED = "UNSUBSCRIBED"
 
 
 @dataclass
@@ -4932,13 +3865,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."""
@@ -5032,69 +3958,10 @@ class RegistryWebhookStatus(Enum):
     TEST_MODE = "TEST_MODE"
 
 
-@dataclass
-class RejectTransitionRequest:
-    name: str
-    """Name of the model."""
-
-    version: str
-    """Version of the model."""
-
-    stage: Stage
-    """Target stage of the transition. Valid values are:
-    
-    * `None`: The initial stage of a model version.
-    
-    * `Staging`: Staging or pre-production stage.
-    
-    * `Production`: Production stage.
-    
-    * `Archived`: Archived stage."""
-
-    comment: Optional[str] = None
-    """User-provided comment on the action."""
-
-    def as_dict(self) -> dict:
-        """Serializes the RejectTransitionRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.comment is not None:
-            body["comment"] = self.comment
-        if self.name is not None:
-            body["name"] = self.name
-        if self.stage is not None:
-            body["stage"] = self.stage.value
-        if self.version is not None:
-            body["version"] = self.version
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the RejectTransitionRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.comment is not None:
-            body["comment"] = self.comment
-        if self.name is not None:
-            body["name"] = self.name
-        if self.stage is not None:
-            body["stage"] = self.stage
-        if self.version is not None:
-            body["version"] = self.version
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> RejectTransitionRequest:
-        """Deserializes the RejectTransitionRequest from a dictionary."""
-        return cls(
-            comment=d.get("comment", None),
-            name=d.get("name", None),
-            stage=_enum(d, "stage", Stage),
-            version=d.get("version", None),
-        )
-
-
 @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."""
@@ -5116,38 +3983,6 @@ class RejectTransitionRequestResponse:
         return cls(activity=_from_dict(d, "activity", Activity))
 
 
-@dataclass
-class RenameModelRequest:
-    name: str
-    """Registered model unique name identifier."""
-
-    new_name: Optional[str] = None
-    """If provided, updates the name for this `registered_model`."""
-
-    def as_dict(self) -> dict:
-        """Serializes the RenameModelRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.name is not None:
-            body["name"] = self.name
-        if self.new_name is not None:
-            body["new_name"] = self.new_name
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the RenameModelRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.name is not None:
-            body["name"] = self.name
-        if self.new_name is not None:
-            body["new_name"] = self.new_name
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> RenameModelRequest:
-        """Deserializes the RenameModelRequest from a dictionary."""
-        return cls(name=d.get("name", None), new_name=d.get("new_name", None))
-
-
 @dataclass
 class RenameModelResponse:
     registered_model: Optional[Model] = None
@@ -5172,31 +4007,6 @@ class RenameModelResponse:
         return cls(registered_model=_from_dict(d, "registered_model", Model))
 
 
-@dataclass
-class RestoreExperiment:
-    experiment_id: str
-    """ID of the associated experiment."""
-
-    def as_dict(self) -> dict:
-        """Serializes the RestoreExperiment into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.experiment_id is not None:
-            body["experiment_id"] = self.experiment_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the RestoreExperiment into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.experiment_id is not None:
-            body["experiment_id"] = self.experiment_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> RestoreExperiment:
-        """Deserializes the RestoreExperiment from a dictionary."""
-        return cls(experiment_id=d.get("experiment_id", None))
-
-
 @dataclass
 class RestoreExperimentResponse:
     def as_dict(self) -> dict:
@@ -5215,31 +4025,6 @@ class RestoreExperimentResponse:
         return cls()
 
 
-@dataclass
-class RestoreRun:
-    run_id: str
-    """ID of the run to restore."""
-
-    def as_dict(self) -> dict:
-        """Serializes the RestoreRun into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the RestoreRun into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> RestoreRun:
-        """Deserializes the RestoreRun from a dictionary."""
-        return cls(run_id=d.get("run_id", None))
-
-
 @dataclass
 class RestoreRunResponse:
     def as_dict(self) -> dict:
@@ -5258,51 +4043,6 @@ class RestoreRunResponse:
         return cls()
 
 
-@dataclass
-class RestoreRuns:
-    experiment_id: str
-    """The ID of the experiment containing the runs to restore."""
-
-    min_timestamp_millis: int
-    """The minimum deletion timestamp in milliseconds since the UNIX epoch for restoring runs. Only
-    runs deleted no earlier than this timestamp are restored."""
-
-    max_runs: Optional[int] = None
-    """An optional positive integer indicating the maximum number of runs to restore. The maximum
-    allowed value for max_runs is 10000."""
-
-    def as_dict(self) -> dict:
-        """Serializes the RestoreRuns into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.experiment_id is not None:
-            body["experiment_id"] = self.experiment_id
-        if self.max_runs is not None:
-            body["max_runs"] = self.max_runs
-        if self.min_timestamp_millis is not None:
-            body["min_timestamp_millis"] = self.min_timestamp_millis
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the RestoreRuns into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.experiment_id is not None:
-            body["experiment_id"] = self.experiment_id
-        if self.max_runs is not None:
-            body["max_runs"] = self.max_runs
-        if self.min_timestamp_millis is not None:
-            body["min_timestamp_millis"] = self.min_timestamp_millis
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> RestoreRuns:
-        """Deserializes the RestoreRuns from a dictionary."""
-        return cls(
-            experiment_id=d.get("experiment_id", None),
-            max_runs=d.get("max_runs", None),
-            min_timestamp_millis=d.get("min_timestamp_millis", None),
-        )
-
-
 @dataclass
 class RestoreRunsResponse:
     runs_restored: Optional[int] = None
@@ -5604,68 +4344,6 @@ class RunTag:
         return cls(key=d.get("key", None), value=d.get("value", None))
 
 
-@dataclass
-class SearchExperiments:
-    filter: Optional[str] = None
-    """String representing a SQL filter condition (e.g. "name ILIKE 'my-experiment%'")"""
-
-    max_results: Optional[int] = None
-    """Maximum number of experiments desired. Max threshold is 3000."""
-
-    order_by: Optional[List[str]] = None
-    """List of columns for ordering search results, which can include experiment name and last updated
-    timestamp with an optional "DESC" or "ASC" annotation, where "ASC" is the default. Tiebreaks are
-    done by experiment id DESC."""
-
-    page_token: Optional[str] = None
-    """Token indicating the page of experiments to fetch"""
-
-    view_type: Optional[ViewType] = None
-    """Qualifier for type of experiments to be returned. If unspecified, return only active
-    experiments."""
-
-    def as_dict(self) -> dict:
-        """Serializes the SearchExperiments into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.filter is not None:
-            body["filter"] = self.filter
-        if self.max_results is not None:
-            body["max_results"] = self.max_results
-        if self.order_by:
-            body["order_by"] = [v for v in self.order_by]
-        if self.page_token is not None:
-            body["page_token"] = self.page_token
-        if self.view_type is not None:
-            body["view_type"] = self.view_type.value
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the SearchExperiments into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.filter is not None:
-            body["filter"] = self.filter
-        if self.max_results is not None:
-            body["max_results"] = self.max_results
-        if self.order_by:
-            body["order_by"] = self.order_by
-        if self.page_token is not None:
-            body["page_token"] = self.page_token
-        if self.view_type is not None:
-            body["view_type"] = self.view_type
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> SearchExperiments:
-        """Deserializes the SearchExperiments from a dictionary."""
-        return cls(
-            filter=d.get("filter", None),
-            max_results=d.get("max_results", None),
-            order_by=d.get("order_by", None),
-            page_token=d.get("page_token", None),
-            view_type=_enum(d, "view_type", ViewType),
-        )
-
-
 @dataclass
 class SearchExperimentsResponse:
     experiments: Optional[List[Experiment]] = None
@@ -5788,80 +4466,6 @@ class SearchLoggedModelsOrderBy:
         )
 
 
-@dataclass
-class SearchLoggedModelsRequest:
-    datasets: Optional[List[SearchLoggedModelsDataset]] = None
-    """List of datasets on which to apply the metrics filter clauses. For example, a filter with
-    `metrics.accuracy > 0.9` and dataset info with name "test_dataset" means we will return all
-    logged models with accuracy > 0.9 on the test_dataset. Metric values from ANY dataset matching
-    the criteria are considered. If no datasets are specified, then metrics across all datasets are
-    considered in the filter."""
-
-    experiment_ids: Optional[List[str]] = None
-    """The IDs of the experiments in which to search for logged models."""
-
-    filter: Optional[str] = None
-    """A filter expression over logged model info and data that allows returning a subset of logged
-    models. The syntax is a subset of SQL that supports AND'ing together binary operations.
-    
-    Example: ``params.alpha < 0.3 AND metrics.accuracy > 0.9``."""
-
-    max_results: Optional[int] = None
-    """The maximum number of Logged Models to return. The maximum limit is 50."""
-
-    order_by: Optional[List[SearchLoggedModelsOrderBy]] = None
-    """The list of columns for ordering the results, with additional fields for sorting criteria."""
-
-    page_token: Optional[str] = None
-    """The token indicating the page of logged models to fetch."""
-
-    def as_dict(self) -> dict:
-        """Serializes the SearchLoggedModelsRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.datasets:
-            body["datasets"] = [v.as_dict() for v in self.datasets]
-        if self.experiment_ids:
-            body["experiment_ids"] = [v for v in self.experiment_ids]
-        if self.filter is not None:
-            body["filter"] = self.filter
-        if self.max_results is not None:
-            body["max_results"] = self.max_results
-        if self.order_by:
-            body["order_by"] = [v.as_dict() for v in self.order_by]
-        if self.page_token is not None:
-            body["page_token"] = self.page_token
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the SearchLoggedModelsRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.datasets:
-            body["datasets"] = self.datasets
-        if self.experiment_ids:
-            body["experiment_ids"] = self.experiment_ids
-        if self.filter is not None:
-            body["filter"] = self.filter
-        if self.max_results is not None:
-            body["max_results"] = self.max_results
-        if self.order_by:
-            body["order_by"] = self.order_by
-        if self.page_token is not None:
-            body["page_token"] = self.page_token
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> SearchLoggedModelsRequest:
-        """Deserializes the SearchLoggedModelsRequest from a dictionary."""
-        return cls(
-            datasets=_repeated_dict(d, "datasets", SearchLoggedModelsDataset),
-            experiment_ids=d.get("experiment_ids", None),
-            filter=d.get("filter", None),
-            max_results=d.get("max_results", None),
-            order_by=_repeated_dict(d, "order_by", SearchLoggedModelsOrderBy),
-            page_token=d.get("page_token", None),
-        )
-
-
 @dataclass
 class SearchLoggedModelsResponse:
     models: Optional[List[LoggedModel]] = None
@@ -5965,95 +4569,15 @@ class SearchModelsResponse:
 
 
 @dataclass
-class SearchRuns:
-    experiment_ids: Optional[List[str]] = None
-    """List of experiment IDs to search over."""
-
-    filter: Optional[str] = None
-    """A filter expression over params, metrics, and tags, that allows returning a subset of runs. The
-    syntax is a subset of SQL that supports ANDing together binary operations between a param,
-    metric, or tag and a constant.
-    
-    Example: `metrics.rmse < 1 and params.model_class = 'LogisticRegression'`
-    
-    You can select columns with special characters (hyphen, space, period, etc.) by using double
-    quotes: `metrics."model class" = 'LinearRegression' and tags."user-name" = 'Tomas'`
-    
-    Supported operators are `=`, `!=`, `>`, `>=`, `<`, and `<=`."""
-
-    max_results: Optional[int] = None
-    """Maximum number of runs desired. Max threshold is 50000"""
-
-    order_by: Optional[List[str]] = None
-    """List of columns to be ordered by, including attributes, params, metrics, and tags with an
-    optional `"DESC"` or `"ASC"` annotation, where `"ASC"` is the default. Example: `["params.input
-    DESC", "metrics.alpha ASC", "metrics.rmse"]`. Tiebreaks are done by start_time `DESC` followed
-    by `run_id` for runs with the same start time (and this is the default ordering criterion if
-    order_by is not provided)."""
-
-    page_token: Optional[str] = None
-    """Token for the current page of runs."""
+class SearchRunsResponse:
+    next_page_token: Optional[str] = None
+    """Token for the next page of runs."""
 
-    run_view_type: Optional[ViewType] = None
-    """Whether to display only active, only deleted, or all runs. Defaults to only active runs."""
+    runs: Optional[List[Run]] = None
+    """Runs that match the search criteria."""
 
     def as_dict(self) -> dict:
-        """Serializes the SearchRuns into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.experiment_ids:
-            body["experiment_ids"] = [v for v in self.experiment_ids]
-        if self.filter is not None:
-            body["filter"] = self.filter
-        if self.max_results is not None:
-            body["max_results"] = self.max_results
-        if self.order_by:
-            body["order_by"] = [v for v in self.order_by]
-        if self.page_token is not None:
-            body["page_token"] = self.page_token
-        if self.run_view_type is not None:
-            body["run_view_type"] = self.run_view_type.value
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the SearchRuns into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.experiment_ids:
-            body["experiment_ids"] = self.experiment_ids
-        if self.filter is not None:
-            body["filter"] = self.filter
-        if self.max_results is not None:
-            body["max_results"] = self.max_results
-        if self.order_by:
-            body["order_by"] = self.order_by
-        if self.page_token is not None:
-            body["page_token"] = self.page_token
-        if self.run_view_type is not None:
-            body["run_view_type"] = self.run_view_type
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> SearchRuns:
-        """Deserializes the SearchRuns from a dictionary."""
-        return cls(
-            experiment_ids=d.get("experiment_ids", None),
-            filter=d.get("filter", None),
-            max_results=d.get("max_results", None),
-            order_by=d.get("order_by", None),
-            page_token=d.get("page_token", None),
-            run_view_type=_enum(d, "run_view_type", ViewType),
-        )
-
-
-@dataclass
-class SearchRunsResponse:
-    next_page_token: Optional[str] = None
-    """Token for the next page of runs."""
-
-    runs: Optional[List[Run]] = None
-    """Runs that match the search criteria."""
-
-    def as_dict(self) -> dict:
-        """Serializes the SearchRunsResponse into a dictionary suitable for use as a JSON request body."""
+        """Serializes the SearchRunsResponse 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
@@ -6076,45 +4600,6 @@ class SearchRunsResponse:
         return cls(next_page_token=d.get("next_page_token", None), runs=_repeated_dict(d, "runs", Run))
 
 
-@dataclass
-class SetExperimentTag:
-    experiment_id: str
-    """ID of the experiment under which to log the tag. Must be provided."""
-
-    key: str
-    """Name of the tag. Keys up to 250 bytes in size are supported."""
-
-    value: str
-    """String value of the tag being logged. Values up to 64KB in size are supported."""
-
-    def as_dict(self) -> dict:
-        """Serializes the SetExperimentTag into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.experiment_id is not None:
-            body["experiment_id"] = self.experiment_id
-        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 SetExperimentTag into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.experiment_id is not None:
-            body["experiment_id"] = self.experiment_id
-        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]) -> SetExperimentTag:
-        """Deserializes the SetExperimentTag from a dictionary."""
-        return cls(experiment_id=d.get("experiment_id", None), key=d.get("key", None), value=d.get("value", None))
-
-
 @dataclass
 class SetExperimentTagResponse:
     def as_dict(self) -> dict:
@@ -6133,38 +4618,6 @@ class SetExperimentTagResponse:
         return cls()
 
 
-@dataclass
-class SetLoggedModelTagsRequest:
-    model_id: Optional[str] = None
-    """The ID of the logged model to set the tags on."""
-
-    tags: Optional[List[LoggedModelTag]] = None
-    """The tags to set on the logged model."""
-
-    def as_dict(self) -> dict:
-        """Serializes the SetLoggedModelTagsRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.model_id is not None:
-            body["model_id"] = self.model_id
-        if self.tags:
-            body["tags"] = [v.as_dict() for v in self.tags]
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the SetLoggedModelTagsRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.model_id is not None:
-            body["model_id"] = self.model_id
-        if self.tags:
-            body["tags"] = self.tags
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> SetLoggedModelTagsRequest:
-        """Deserializes the SetLoggedModelTagsRequest from a dictionary."""
-        return cls(model_id=d.get("model_id", None), tags=_repeated_dict(d, "tags", LoggedModelTag))
-
-
 @dataclass
 class SetLoggedModelTagsResponse:
     def as_dict(self) -> dict:
@@ -6183,48 +4636,6 @@ class SetLoggedModelTagsResponse:
         return cls()
 
 
-@dataclass
-class SetModelTagRequest:
-    name: str
-    """Unique name of the model."""
-
-    key: str
-    """Name of the tag. Maximum size depends on storage backend. If a tag with this name already
-    exists, its preexisting value will be replaced by the specified `value`. All storage backends
-    are guaranteed to support key values up to 250 bytes in size."""
-
-    value: str
-    """String value of the tag being logged. Maximum size depends on storage backend. All storage
-    backends are guaranteed to support key values up to 5000 bytes in size."""
-
-    def as_dict(self) -> dict:
-        """Serializes the SetModelTagRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.key is not None:
-            body["key"] = self.key
-        if self.name is not None:
-            body["name"] = self.name
-        if self.value is not None:
-            body["value"] = self.value
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the SetModelTagRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.key is not None:
-            body["key"] = self.key
-        if self.name is not None:
-            body["name"] = self.name
-        if self.value is not None:
-            body["value"] = self.value
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> SetModelTagRequest:
-        """Deserializes the SetModelTagRequest from a dictionary."""
-        return cls(key=d.get("key", None), name=d.get("name", None), value=d.get("value", None))
-
-
 @dataclass
 class SetModelTagResponse:
     def as_dict(self) -> dict:
@@ -6243,57 +4654,6 @@ class SetModelTagResponse:
         return cls()
 
 
-@dataclass
-class SetModelVersionTagRequest:
-    name: str
-    """Unique name of the model."""
-
-    version: str
-    """Model version number."""
-
-    key: str
-    """Name of the tag. Maximum size depends on storage backend. If a tag with this name already
-    exists, its preexisting value will be replaced by the specified `value`. All storage backends
-    are guaranteed to support key values up to 250 bytes in size."""
-
-    value: str
-    """String value of the tag being logged. Maximum size depends on storage backend. All storage
-    backends are guaranteed to support key values up to 5000 bytes in size."""
-
-    def as_dict(self) -> dict:
-        """Serializes the SetModelVersionTagRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.key is not None:
-            body["key"] = self.key
-        if self.name is not None:
-            body["name"] = self.name
-        if self.value is not None:
-            body["value"] = self.value
-        if self.version is not None:
-            body["version"] = self.version
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the SetModelVersionTagRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.key is not None:
-            body["key"] = self.key
-        if self.name is not None:
-            body["name"] = self.name
-        if self.value is not None:
-            body["value"] = self.value
-        if self.version is not None:
-            body["version"] = self.version
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> SetModelVersionTagRequest:
-        """Deserializes the SetModelVersionTagRequest from a dictionary."""
-        return cls(
-            key=d.get("key", None), name=d.get("name", None), value=d.get("value", None), version=d.get("version", None)
-        )
-
-
 @dataclass
 class SetModelVersionTagResponse:
     def as_dict(self) -> dict:
@@ -6312,58 +4672,6 @@ class SetModelVersionTagResponse:
         return cls()
 
 
-@dataclass
-class SetTag:
-    key: str
-    """Name of the tag. Keys up to 250 bytes in size are supported."""
-
-    value: str
-    """String value of the tag being logged. Values up to 64KB in size are supported."""
-
-    run_id: Optional[str] = None
-    """ID of the run under which to log the tag. Must be provided."""
-
-    run_uuid: Optional[str] = None
-    """[Deprecated, use `run_id` instead] ID of the run under which to log the tag. This field will be
-    removed in a future MLflow version."""
-
-    def as_dict(self) -> dict:
-        """Serializes the SetTag into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.key is not None:
-            body["key"] = self.key
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        if self.run_uuid is not None:
-            body["run_uuid"] = self.run_uuid
-        if self.value is not None:
-            body["value"] = self.value
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the SetTag into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.key is not None:
-            body["key"] = self.key
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        if self.run_uuid is not None:
-            body["run_uuid"] = self.run_uuid
-        if self.value is not None:
-            body["value"] = self.value
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> SetTag:
-        """Deserializes the SetTag from a dictionary."""
-        return cls(
-            key=d.get("key", None),
-            run_id=d.get("run_id", None),
-            run_uuid=d.get("run_uuid", None),
-            value=d.get("value", None),
-        )
-
-
 @dataclass
 class SetTagResponse:
     def as_dict(self) -> dict:
@@ -6382,23 +4690,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.
@@ -6413,9 +4704,7 @@ class Status(Enum):
 
 
 @dataclass
-class TestRegistryWebhook:
-    """Test webhook response object."""
-
+class TestRegistryWebhookResponse:
     body: Optional[str] = None
     """Body of the response from the webhook URL"""
 
@@ -6423,7 +4712,7 @@ class TestRegistryWebhook:
     """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."""
+        """Serializes the TestRegistryWebhookResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.body is not None:
             body["body"] = self.body
@@ -6432,7 +4721,7 @@ class TestRegistryWebhook:
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the TestRegistryWebhook into a shallow dictionary of its immediate attributes."""
+        """Serializes the TestRegistryWebhookResponse into a shallow dictionary of its immediate attributes."""
         body = {}
         if self.body is not None:
             body["body"] = self.body
@@ -6440,151 +4729,27 @@ class TestRegistryWebhook:
             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:
-    id: str
-    """Webhook ID"""
-
-    event: Optional[RegistryWebhookEvent] = None
-    """If `event` is specified, the test trigger uses the specified event. If `event` is not specified,
-    the test trigger uses a randomly chosen event associated with the webhook."""
-
-    def as_dict(self) -> dict:
-        """Serializes the TestRegistryWebhookRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.event is not None:
-            body["event"] = self.event.value
-        if self.id is not None:
-            body["id"] = self.id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the TestRegistryWebhookRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.event is not None:
-            body["event"] = self.event
-        if self.id is not None:
-            body["id"] = self.id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> TestRegistryWebhookRequest:
-        """Deserializes the TestRegistryWebhookRequest from a dictionary."""
-        return cls(event=_enum(d, "event", RegistryWebhookEvent), id=d.get("id", None))
-
-
-@dataclass
-class TestRegistryWebhookResponse:
-    webhook: Optional[TestRegistryWebhook] = None
-    """Test webhook response object."""
-
-    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()
-        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
-        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))
-
-
-@dataclass
-class TransitionModelVersionStageDatabricks:
-    name: str
-    """Name of the model."""
-
-    version: str
-    """Version of the model."""
-
-    stage: Stage
-    """Target stage of the transition. Valid values are:
-    
-    * `None`: The initial stage of a model version.
-    
-    * `Staging`: Staging or pre-production stage.
-    
-    * `Production`: Production stage.
-    
-    * `Archived`: Archived stage."""
-
-    archive_existing_versions: bool
-    """Specifies whether to archive all current model versions in the target stage."""
-
-    comment: Optional[str] = None
-    """User-provided comment on the action."""
-
-    def as_dict(self) -> dict:
-        """Serializes the TransitionModelVersionStageDatabricks into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.archive_existing_versions is not None:
-            body["archive_existing_versions"] = self.archive_existing_versions
-        if self.comment is not None:
-            body["comment"] = self.comment
-        if self.name is not None:
-            body["name"] = self.name
-        if self.stage is not None:
-            body["stage"] = self.stage.value
-        if self.version is not None:
-            body["version"] = self.version
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the TransitionModelVersionStageDatabricks into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.archive_existing_versions is not None:
-            body["archive_existing_versions"] = self.archive_existing_versions
-        if self.comment is not None:
-            body["comment"] = self.comment
-        if self.name is not None:
-            body["name"] = self.name
-        if self.stage is not None:
-            body["stage"] = self.stage
-        if self.version is not None:
-            body["version"] = self.version
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> TransitionModelVersionStageDatabricks:
-        """Deserializes the TransitionModelVersionStageDatabricks from a dictionary."""
-        return cls(
-            archive_existing_versions=d.get("archive_existing_versions", None),
-            comment=d.get("comment", None),
-            name=d.get("name", None),
-            stage=_enum(d, "stage", Stage),
-            version=d.get("version", None),
-        )
+        return cls(body=d.get("body", None), status_code=d.get("status_code", 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.
@@ -6608,7 +4773,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
@@ -6635,71 +4800,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))
-
-
-@dataclass
-class UpdateComment:
-    id: str
-    """Unique identifier of an activity"""
-
-    comment: str
-    """User-provided comment on the action."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateComment into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.comment is not None:
-            body["comment"] = self.comment
-        if self.id is not None:
-            body["id"] = self.id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateComment into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.comment is not None:
-            body["comment"] = self.comment
-        if self.id is not None:
-            body["id"] = self.id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> UpdateComment:
-        """Deserializes the UpdateComment from a dictionary."""
-        return cls(comment=d.get("comment", None), id=d.get("id", None))
+        return cls(model_version_databricks=_from_dict(d, "model_version_databricks", ModelVersionDatabricks))
 
 
 @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."""
@@ -6721,319 +4855,71 @@ class UpdateCommentResponse:
         return cls(comment=_from_dict(d, "comment", CommentObject))
 
 
-@dataclass
-class UpdateExperiment:
-    experiment_id: str
-    """ID of the associated experiment."""
-
-    new_name: Optional[str] = None
-    """If provided, the experiment's name is changed to the new name. The new name must be unique."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateExperiment into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.experiment_id is not None:
-            body["experiment_id"] = self.experiment_id
-        if self.new_name is not None:
-            body["new_name"] = self.new_name
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateExperiment into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.experiment_id is not None:
-            body["experiment_id"] = self.experiment_id
-        if self.new_name is not None:
-            body["new_name"] = self.new_name
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> UpdateExperiment:
-        """Deserializes the UpdateExperiment from a dictionary."""
-        return cls(experiment_id=d.get("experiment_id", None), new_name=d.get("new_name", None))
-
-
-@dataclass
-class UpdateExperimentResponse:
-    def as_dict(self) -> dict:
-        """Serializes the UpdateExperimentResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateExperimentResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> UpdateExperimentResponse:
-        """Deserializes the UpdateExperimentResponse from a dictionary."""
-        return cls()
-
-
-@dataclass
-class UpdateModelRequest:
-    name: str
-    """Registered model unique name identifier."""
-
-    description: Optional[str] = None
-    """If provided, updates the description for this `registered_model`."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateModelRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.description is not None:
-            body["description"] = self.description
-        if self.name is not None:
-            body["name"] = self.name
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateModelRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.description is not None:
-            body["description"] = self.description
-        if self.name is not None:
-            body["name"] = self.name
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> UpdateModelRequest:
-        """Deserializes the UpdateModelRequest from a dictionary."""
-        return cls(description=d.get("description", None), name=d.get("name", None))
-
-
-@dataclass
-class UpdateModelResponse:
-    def as_dict(self) -> dict:
-        """Serializes the UpdateModelResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateModelResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> UpdateModelResponse:
-        """Deserializes the UpdateModelResponse from a dictionary."""
-        return cls()
-
-
-@dataclass
-class UpdateModelVersionRequest:
-    name: str
-    """Name of the registered model"""
-
-    version: str
-    """Model version number"""
-
-    description: Optional[str] = None
-    """If provided, updates the description for this `registered_model`."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateModelVersionRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.description is not None:
-            body["description"] = self.description
-        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 UpdateModelVersionRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.description is not None:
-            body["description"] = self.description
-        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]) -> UpdateModelVersionRequest:
-        """Deserializes the UpdateModelVersionRequest from a dictionary."""
-        return cls(description=d.get("description", None), name=d.get("name", None), version=d.get("version", None))
-
-
-@dataclass
-class UpdateModelVersionResponse:
-    def as_dict(self) -> dict:
-        """Serializes the UpdateModelVersionResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateModelVersionResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> UpdateModelVersionResponse:
-        """Deserializes the UpdateModelVersionResponse from a dictionary."""
-        return cls()
-
-
-@dataclass
-class UpdateRegistryWebhook:
-    id: str
-    """Webhook ID"""
-
-    description: Optional[str] = None
-    """User-specified description for the webhook."""
-
-    events: Optional[List[RegistryWebhookEvent]] = None
-    """Events that can trigger a registry webhook: * `MODEL_VERSION_CREATED`: A new model version was
-    created for the associated model.
-    
-    * `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."""
-
-    http_url_spec: Optional[HttpUrlSpec] = None
-
-    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."""
-
+@dataclass
+class UpdateExperimentResponse:
     def as_dict(self) -> dict:
-        """Serializes the UpdateRegistryWebhook into a dictionary suitable for use as a JSON request body."""
+        """Serializes the UpdateExperimentResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.description is not None:
-            body["description"] = self.description
-        if self.events:
-            body["events"] = [v.value for v in self.events]
-        if self.http_url_spec:
-            body["http_url_spec"] = self.http_url_spec.as_dict()
-        if self.id is not None:
-            body["id"] = self.id
-        if self.job_spec:
-            body["job_spec"] = self.job_spec.as_dict()
-        if self.status is not None:
-            body["status"] = self.status.value
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateRegistryWebhook into a shallow dictionary of its immediate attributes."""
+        """Serializes the UpdateExperimentResponse into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.description is not None:
-            body["description"] = self.description
-        if self.events:
-            body["events"] = self.events
-        if self.http_url_spec:
-            body["http_url_spec"] = self.http_url_spec
-        if self.id is not None:
-            body["id"] = self.id
-        if self.job_spec:
-            body["job_spec"] = self.job_spec
-        if self.status is not None:
-            body["status"] = self.status
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> UpdateRegistryWebhook:
-        """Deserializes the UpdateRegistryWebhook from a dictionary."""
-        return cls(
-            description=d.get("description", None),
-            events=_repeated_enum(d, "events", RegistryWebhookEvent),
-            http_url_spec=_from_dict(d, "http_url_spec", HttpUrlSpec),
-            id=d.get("id", None),
-            job_spec=_from_dict(d, "job_spec", JobSpec),
-            status=_enum(d, "status", RegistryWebhookStatus),
-        )
+    def from_dict(cls, d: Dict[str, Any]) -> UpdateExperimentResponse:
+        """Deserializes the UpdateExperimentResponse from a dictionary."""
+        return cls()
 
 
 @dataclass
-class UpdateRun:
-    end_time: Optional[int] = None
-    """Unix timestamp in milliseconds of when the run ended."""
+class UpdateModelResponse:
+    registered_model: Optional[Model] = None
 
-    run_id: Optional[str] = None
-    """ID of the run to update. Must be provided."""
+    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
 
-    run_name: Optional[str] = None
-    """Updated name of the run."""
+    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
 
-    run_uuid: Optional[str] = None
-    """[Deprecated, use `run_id` instead] ID of the run to update. This field will be removed in a
-    future MLflow version."""
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> UpdateModelResponse:
+        """Deserializes the UpdateModelResponse from a dictionary."""
+        return cls(registered_model=_from_dict(d, "registered_model", Model))
 
-    status: Optional[UpdateRunStatus] = None
-    """Updated status of the run."""
+
+@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 UpdateRun into a dictionary suitable for use as a JSON request body."""
+        """Serializes the UpdateModelVersionResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.end_time is not None:
-            body["end_time"] = self.end_time
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        if self.run_name is not None:
-            body["run_name"] = self.run_name
-        if self.run_uuid is not None:
-            body["run_uuid"] = self.run_uuid
-        if self.status is not None:
-            body["status"] = self.status.value
+        if self.model_version:
+            body["model_version"] = self.model_version.as_dict()
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateRun into a shallow dictionary of its immediate attributes."""
+        """Serializes the UpdateModelVersionResponse into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.end_time is not None:
-            body["end_time"] = self.end_time
-        if self.run_id is not None:
-            body["run_id"] = self.run_id
-        if self.run_name is not None:
-            body["run_name"] = self.run_name
-        if self.run_uuid is not None:
-            body["run_uuid"] = self.run_uuid
-        if self.status is not None:
-            body["status"] = self.status
+        if self.model_version:
+            body["model_version"] = self.model_version
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> UpdateRun:
-        """Deserializes the UpdateRun from a dictionary."""
-        return cls(
-            end_time=d.get("end_time", None),
-            run_id=d.get("run_id", None),
-            run_name=d.get("run_name", None),
-            run_uuid=d.get("run_uuid", None),
-            status=_enum(d, "status", UpdateRunStatus),
-        )
+    def from_dict(cls, d: Dict[str, Any]) -> UpdateModelVersionResponse:
+        """Deserializes the UpdateModelVersionResponse from a dictionary."""
+        return cls(model_version=_from_dict(d, "model_version", ModelVersion))
 
 
 @dataclass
@@ -7073,20 +4959,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):
@@ -8380,7 +6272,7 @@ class FeatureStoreAPI:
         """Create an Online Feature Store.
 
         :param online_store: :class:`OnlineStore`
-          An OnlineStore is a logical database instance that stores and serves features online.
+          Online store to create.
 
         :returns: :class:`OnlineStore`
         """
@@ -8484,7 +6376,7 @@ class FeatureStoreAPI:
         :param name: str
           The name of the online store. This is the unique identifier for the online store.
         :param online_store: :class:`OnlineStore`
-          An OnlineStore is a logical database instance that stores and serves features online.
+          Online store to update.
         :param update_mask: str
           The list of fields to update.
 
@@ -8728,6 +6620,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
@@ -8741,7 +6806,7 @@ 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:
         """Approves a model version stage transition request.
 
@@ -8749,7 +6814,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.
@@ -8774,7 +6839,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 = {
@@ -8816,9 +6881,8 @@ class ModelRegistryAPI:
     def create_model(
         self, name: str, *, description: Optional[str] = None, tags: Optional[List[ModelTag]] = None
     ) -> CreateModelResponse:
-        """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
@@ -8895,7 +6959,7 @@ 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:
         """Creates a model version stage transition request.
 
@@ -8903,7 +6967,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.
@@ -8924,7 +6988,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 = {
@@ -8945,9 +7009,7 @@ class ModelRegistryAPI:
         model_name: Optional[str] = None,
         status: Optional[RegistryWebhookStatus] = None,
     ) -> CreateWebhookResponse:
-        """**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
@@ -8981,7 +7043,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.
@@ -9126,21 +7190,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,
-    ):
+        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.
@@ -9156,7 +7214,7 @@ class ModelRegistryAPI:
         :param comment: str (optional)
           User-provided comment on the action.
 
-
+        :returns: :class:`DeleteTransitionRequestResponse`
         """
 
         query = {}
@@ -9167,21 +7225,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)
+        res = self._api.do("DELETE", "/api/2.0/mlflow/transition-requests/delete", query=query, headers=headers)
+        return DeleteTransitionRequestResponse.from_dict(res)
 
-    def delete_webhook(self, *, id: Optional[str] = None):
-        """**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.
 
 
@@ -9357,7 +7414,7 @@ class ModelRegistryAPI:
         """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.
 
@@ -9381,19 +7438,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]:
-        """**NOTE:** This endpoint is in Public Preview.
-
-        Lists all registry webhooks.
+        """**NOTE:** This endpoint is in Public Preview. Lists all registry webhooks.
 
         :param events: List[:class:`RegistryWebhookEvent`] (optional)
+          Events that trigger the webhook. * `MODEL_VERSION_CREATED`: A new model version was created for the
+          associated model.
+
+          * `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.
+
           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
 
@@ -9403,6 +7489,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:
@@ -9421,7 +7509,7 @@ 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:
         """Rejects a model version stage transition request.
 
@@ -9429,7 +7517,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.
@@ -9450,7 +7538,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 = {
@@ -9672,9 +7760,7 @@ class ModelRegistryAPI:
     def test_registry_webhook(
         self, id: str, *, event: Optional[RegistryWebhookEvent] = None
     ) -> TestRegistryWebhookResponse:
-        """**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
@@ -9698,10 +7784,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 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.",
+        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
 
@@ -9709,7 +7795,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.
@@ -9734,7 +7820,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 = {
@@ -9770,7 +7856,7 @@ 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):
+    def update_model(self, name: str, *, description: Optional[str] = None) -> UpdateModelResponse:
         """Updates a registered model.
 
         :param name: str
@@ -9778,7 +7864,7 @@ class ModelRegistryAPI:
         :param description: str (optional)
           If provided, updates the description for this `registered_model`.
 
-
+        :returns: :class:`UpdateModelResponse`
         """
         body = {}
         if description is not None:
@@ -9790,9 +7876,12 @@ class ModelRegistryAPI:
             "Content-Type": "application/json",
         }
 
-        self._api.do("PATCH", "/api/2.0/mlflow/registered-models/update", body=body, headers=headers)
+        res = self._api.do("PATCH", "/api/2.0/mlflow/registered-models/update", body=body, headers=headers)
+        return UpdateModelResponse.from_dict(res)
 
-    def update_model_version(self, name: str, version: str, *, description: Optional[str] = None):
+    def update_model_version(
+        self, name: str, version: str, *, description: Optional[str] = None
+    ) -> UpdateModelVersionResponse:
         """Updates the model version.
 
         :param name: str
@@ -9802,7 +7891,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:
@@ -9816,7 +7905,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,
@@ -9855,10 +7945,8 @@ class ModelRegistryAPI:
         http_url_spec: Optional[HttpUrlSpec] = None,
         job_spec: Optional[JobSpec] = None,
         status: Optional[RegistryWebhookStatus] = None,
-    ):
-        """**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
@@ -9896,15 +7984,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:
@@ -9924,4 +8005,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)