databricks-sdk 0.0.7__py3-none-any.whl → 0.1.1__py3-none-any.whl

databricks/sdk/service/{mlflow.py → ml.py}

@@ -72,20 +72,6 @@ class ActivityType(Enum):
     SYSTEM_TRANSITION = 'SYSTEM_TRANSITION'
 
 
-@dataclass
-class ApproveResponse:
-    activity: 'Activity' = None
-
-    def as_dict(self) -> dict:
-        body = {}
-        if self.activity: body['activity'] = self.activity.as_dict()
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'ApproveResponse':
-        return cls(activity=_from_dict(d, 'activity', Activity))
-
-
 @dataclass
 class ApproveTransitionRequest:
     name: str
@@ -112,6 +98,20 @@ class ApproveTransitionRequest:
                    version=d.get('version', None))
 
 
+@dataclass
+class ApproveTransitionRequestResponse:
+    activity: 'Activity' = None
+
+    def as_dict(self) -> dict:
+        body = {}
+        if self.activity: body['activity'] = self.activity.as_dict()
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> 'ApproveTransitionRequestResponse':
+        return cls(activity=_from_dict(d, 'activity', Activity))
+
+
 class CommentActivityAction(Enum):
     """This describes an enum"""
 
@@ -126,6 +126,7 @@ class CommentObject:
     available_actions: 'List[CommentActivityAction]' = None
     comment: str = None
     creation_timestamp: int = None
+    id: str = None
     last_updated_timestamp: int = None
     user_id: str = None
 
@@ -134,6 +135,7 @@ class CommentObject:
         if self.available_actions: body['available_actions'] = [v for v in self.available_actions]
         if self.comment: body['comment'] = self.comment
         if self.creation_timestamp: body['creation_timestamp'] = self.creation_timestamp
+        if self.id: body['id'] = self.id
         if self.last_updated_timestamp: body['last_updated_timestamp'] = self.last_updated_timestamp
         if self.user_id: body['user_id'] = self.user_id
         return body
@@ -143,6 +145,7 @@ class CommentObject:
         return cls(available_actions=d.get('available_actions', None),
                    comment=d.get('comment', None),
                    creation_timestamp=d.get('creation_timestamp', None),
+                   id=d.get('id', None),
                    last_updated_timestamp=d.get('last_updated_timestamp', None),
                    user_id=d.get('user_id', None))
 
@@ -165,6 +168,20 @@ class CreateComment:
         return cls(comment=d.get('comment', None), name=d.get('name', None), version=d.get('version', None))
 
 
+@dataclass
+class CreateCommentResponse:
+    comment: 'CommentObject' = None
+
+    def as_dict(self) -> dict:
+        body = {}
+        if self.comment: body['comment'] = self.comment.as_dict()
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> 'CreateCommentResponse':
+        return cls(comment=_from_dict(d, 'comment', CommentObject))
+
+
 @dataclass
 class CreateExperiment:
     name: str
@@ -200,80 +217,80 @@ class CreateExperimentResponse:
 
 
 @dataclass
-class CreateModelVersionRequest:
+class CreateModelRequest:
     name: str
-    source: str
     description: str = None
-    run_id: str = None
-    run_link: str = None
-    tags: 'List[ModelVersionTag]' = None
+    tags: 'List[ModelTag]' = None
 
     def as_dict(self) -> dict:
         body = {}
         if self.description: body['description'] = self.description
         if self.name: body['name'] = self.name
-        if self.run_id: body['run_id'] = self.run_id
-        if self.run_link: body['run_link'] = self.run_link
-        if self.source: body['source'] = self.source
         if self.tags: body['tags'] = [v.as_dict() for v in self.tags]
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'CreateModelVersionRequest':
+    def from_dict(cls, d: Dict[str, any]) -> 'CreateModelRequest':
         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(d, 'tags', ModelVersionTag))
+                   tags=_repeated(d, 'tags', ModelTag))
 
 
 @dataclass
-class CreateModelVersionResponse:
-    model_version: 'ModelVersion' = None
+class CreateModelResponse:
+    registered_model: 'Model' = None
 
     def as_dict(self) -> dict:
         body = {}
-        if self.model_version: body['model_version'] = self.model_version.as_dict()
+        if self.registered_model: body['registered_model'] = self.registered_model.as_dict()
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'CreateModelVersionResponse':
-        return cls(model_version=_from_dict(d, 'model_version', ModelVersion))
+    def from_dict(cls, d: Dict[str, any]) -> 'CreateModelResponse':
+        return cls(registered_model=_from_dict(d, 'registered_model', Model))
 
 
 @dataclass
-class CreateRegisteredModelRequest:
+class CreateModelVersionRequest:
     name: str
+    source: str
     description: str = None
-    tags: 'List[RegisteredModelTag]' = None
+    run_id: str = None
+    run_link: str = None
+    tags: 'List[ModelVersionTag]' = None
 
     def as_dict(self) -> dict:
         body = {}
         if self.description: body['description'] = self.description
         if self.name: body['name'] = self.name
+        if self.run_id: body['run_id'] = self.run_id
+        if self.run_link: body['run_link'] = self.run_link
+        if self.source: body['source'] = self.source
         if self.tags: body['tags'] = [v.as_dict() for v in self.tags]
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'CreateRegisteredModelRequest':
+    def from_dict(cls, d: Dict[str, any]) -> 'CreateModelVersionRequest':
         return cls(description=d.get('description', None),
                    name=d.get('name', None),
-                   tags=_repeated(d, 'tags', RegisteredModelTag))
+                   run_id=d.get('run_id', None),
+                   run_link=d.get('run_link', None),
+                   source=d.get('source', None),
+                   tags=_repeated(d, 'tags', ModelVersionTag))
 
 
 @dataclass
-class CreateRegisteredModelResponse:
-    registered_model: 'RegisteredModel' = None
+class CreateModelVersionResponse:
+    model_version: 'ModelVersion' = None
 
     def as_dict(self) -> dict:
         body = {}
-        if self.registered_model: body['registered_model'] = self.registered_model.as_dict()
+        if self.model_version: body['model_version'] = self.model_version.as_dict()
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'CreateRegisteredModelResponse':
-        return cls(registered_model=_from_dict(d, 'registered_model', RegisteredModel))
+    def from_dict(cls, d: Dict[str, any]) -> 'CreateModelVersionResponse':
+        return cls(model_version=_from_dict(d, 'model_version', ModelVersion))
 
 
 @dataclass
@@ -305,20 +322,6 @@ class CreateRegistryWebhook:
                    status=_enum(d, 'status', RegistryWebhookStatus))
 
 
-@dataclass
-class CreateResponse:
-    comment: 'CommentObject' = None
-
-    def as_dict(self) -> dict:
-        body = {}
-        if self.comment: body['comment'] = self.comment.as_dict()
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'CreateResponse':
-        return cls(comment=_from_dict(d, 'comment', CommentObject))
-
-
 @dataclass
 class CreateRun:
     experiment_id: str = None
@@ -380,52 +383,63 @@ class CreateTransitionRequest:
 
 
 @dataclass
-class DeleteExperiment:
-    experiment_id: str
+class CreateTransitionRequestResponse:
+    request: 'TransitionRequest' = None
 
     def as_dict(self) -> dict:
         body = {}
-        if self.experiment_id: body['experiment_id'] = self.experiment_id
+        if self.request: body['request'] = self.request.as_dict()
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'DeleteExperiment':
-        return cls(experiment_id=d.get('experiment_id', None))
+    def from_dict(cls, d: Dict[str, any]) -> 'CreateTransitionRequestResponse':
+        return cls(request=_from_dict(d, 'request', TransitionRequest))
 
 
 @dataclass
-class DeleteModelVersionCommentRequest:
-    """Delete a comment"""
+class CreateWebhookResponse:
+    webhook: 'RegistryWebhook' = None
 
-    id: str
+    def as_dict(self) -> dict:
+        body = {}
+        if self.webhook: body['webhook'] = self.webhook.as_dict()
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> 'CreateWebhookResponse':
+        return cls(webhook=_from_dict(d, 'webhook', RegistryWebhook))
 
 
 @dataclass
-class DeleteModelVersionRequest:
-    """Delete a model version."""
+class DeleteCommentRequest:
+    """Delete a comment"""
 
-    name: str
-    version: str
+    id: str
 
 
 @dataclass
-class DeleteModelVersionTagRequest:
-    """Delete a model version tag"""
+class DeleteExperiment:
+    experiment_id: str
 
-    name: str
-    version: str
-    key: str
+    def as_dict(self) -> dict:
+        body = {}
+        if self.experiment_id: body['experiment_id'] = self.experiment_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> 'DeleteExperiment':
+        return cls(experiment_id=d.get('experiment_id', None))
 
 
 @dataclass
-class DeleteRegisteredModelRequest:
+class DeleteModelRequest:
     """Delete a model"""
 
     name: str
 
 
 @dataclass
-class DeleteRegisteredModelTagRequest:
+class DeleteModelTagRequest:
     """Delete a model tag"""
 
     name: str
@@ -433,10 +447,20 @@ class DeleteRegisteredModelTagRequest:
 
 
 @dataclass
-class DeleteRegistryWebhookRequest:
-    """Delete a webhook"""
+class DeleteModelVersionRequest:
+    """Delete a model version."""
 
-    id: str = None
+    name: str
+    version: str
+
+
+@dataclass
+class DeleteModelVersionTagRequest:
+    """Delete a model version tag"""
+
+    name: str
+    version: str
+    key: str
 
 
 @dataclass
@@ -480,6 +504,13 @@ class DeleteTransitionRequestRequest:
     comment: str = None
 
 
+@dataclass
+class DeleteWebhookRequest:
+    """Delete a webhook"""
+
+    id: str = None
+
+
 @dataclass
 class Experiment:
     artifact_location: str = None
@@ -615,13 +646,6 @@ class GetLatestVersionsResponse:
         return cls(model_versions=_repeated(d, 'model_versions', ModelVersion))
 
 
-@dataclass
-class GetMLflowDatabrickRequest:
-    """Get model"""
-
-    name: str
-
-
 @dataclass
 class GetMetricHistoryResponse:
     metrics: 'List[Metric]' = None
@@ -638,6 +662,27 @@ class GetMetricHistoryResponse:
         return cls(metrics=_repeated(d, 'metrics', Metric), next_page_token=d.get('next_page_token', None))
 
 
+@dataclass
+class GetModelRequest:
+    """Get model"""
+
+    name: str
+
+
+@dataclass
+class GetModelResponse:
+    registered_model: 'ModelDatabricks' = None
+
+    def as_dict(self) -> dict:
+        body = {}
+        if self.registered_model: body['registered_model'] = self.registered_model.as_dict()
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> 'GetModelResponse':
+        return cls(registered_model=_from_dict(d, 'registered_model', ModelDatabricks))
+
+
 @dataclass
 class GetModelVersionDownloadUriRequest:
     """Get a model version URI"""
@@ -682,41 +727,6 @@ class GetModelVersionResponse:
         return cls(model_version=_from_dict(d, 'model_version', ModelVersion))
 
 
-@dataclass
-class GetRegisteredModelRequest:
-    """Get a model"""
-
-    name: str
-
-
-@dataclass
-class GetRegisteredModelResponse:
-    registered_model: 'RegisteredModel' = None
-
-    def as_dict(self) -> dict:
-        body = {}
-        if self.registered_model: body['registered_model'] = self.registered_model.as_dict()
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'GetRegisteredModelResponse':
-        return cls(registered_model=_from_dict(d, 'registered_model', RegisteredModel))
-
-
-@dataclass
-class GetResponse:
-    registered_model: 'RegisteredModelDatabricks' = None
-
-    def as_dict(self) -> dict:
-        body = {}
-        if self.registered_model: body['registered_model'] = self.registered_model.as_dict()
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'GetResponse':
-        return cls(registered_model=_from_dict(d, 'registered_model', RegisteredModelDatabricks))
-
-
 @dataclass
 class GetRunRequest:
     """Get a run"""
@@ -871,7 +881,7 @@ class ListExperimentsResponse:
 
 
 @dataclass
-class ListRegisteredModelsRequest:
+class ListModelsRequest:
     """List models"""
 
     max_results: int = None
@@ -879,9 +889,9 @@ class ListRegisteredModelsRequest:
 
 
 @dataclass
-class ListRegisteredModelsResponse:
+class ListModelsResponse:
     next_page_token: str = None
-    registered_models: 'List[RegisteredModel]' = None
+    registered_models: 'List[Model]' = None
 
     def as_dict(self) -> dict:
         body = {}
@@ -890,9 +900,9 @@ class ListRegisteredModelsResponse:
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'ListRegisteredModelsResponse':
+    def from_dict(cls, d: Dict[str, any]) -> 'ListModelsResponse':
         return cls(next_page_token=d.get('next_page_token', None),
-                   registered_models=_repeated(d, 'registered_models', RegisteredModel))
+                   registered_models=_repeated(d, 'registered_models', Model))
 
 
 @dataclass
@@ -913,16 +923,15 @@ class ListRegistryWebhooks:
 
 
 @dataclass
-class ListRegistryWebhooksRequest:
-    """List registry webhooks"""
+class ListTransitionRequestsRequest:
+    """List transition requests"""
 
-    events: 'List[RegistryWebhookEvent]' = None
-    model_name: str = None
-    page_token: str = None
+    name: str
+    version: str
 
 
 @dataclass
-class ListResponse:
+class ListTransitionRequestsResponse:
     requests: 'List[Activity]' = None
 
     def as_dict(self) -> dict:
@@ -931,16 +940,17 @@ class ListResponse:
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'ListResponse':
+    def from_dict(cls, d: Dict[str, any]) -> 'ListTransitionRequestsResponse':
         return cls(requests=_repeated(d, 'requests', Activity))
 
 
 @dataclass
-class ListTransitionRequestsRequest:
-    """List transition requests"""
+class ListWebhooksRequest:
+    """List registry webhooks"""
 
-    name: str
-    version: str
+    events: 'List[RegistryWebhookEvent]' = None
+    model_name: str = None
+    page_token: str = None
 
 
 @dataclass
@@ -1058,134 +1068,77 @@ class Metric:
 
 
 @dataclass
-class ModelVersion:
+class Model:
     creation_timestamp: int = None
-    current_stage: str = None
     description: str = None
     last_updated_timestamp: int = None
+    latest_versions: 'List[ModelVersion]' = None
     name: str = None
-    run_id: str = None
-    run_link: str = None
-    source: str = None
-    status: 'ModelVersionStatus' = None
-    status_message: str = None
-    tags: 'List[ModelVersionTag]' = None
+    tags: 'List[ModelTag]' = None
     user_id: str = None
-    version: str = None
 
     def as_dict(self) -> dict:
         body = {}
         if self.creation_timestamp: body['creation_timestamp'] = self.creation_timestamp
-        if self.current_stage: body['current_stage'] = self.current_stage
         if self.description: body['description'] = self.description
         if self.last_updated_timestamp: body['last_updated_timestamp'] = self.last_updated_timestamp
+        if self.latest_versions: body['latest_versions'] = [v.as_dict() for v in self.latest_versions]
         if self.name: body['name'] = self.name
-        if self.run_id: body['run_id'] = self.run_id
-        if self.run_link: body['run_link'] = self.run_link
-        if self.source: body['source'] = self.source
-        if self.status: body['status'] = self.status.value
-        if self.status_message: body['status_message'] = self.status_message
         if self.tags: body['tags'] = [v.as_dict() for v in self.tags]
         if self.user_id: body['user_id'] = self.user_id
-        if self.version: body['version'] = self.version
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'ModelVersion':
+    def from_dict(cls, d: Dict[str, any]) -> 'Model':
         return cls(creation_timestamp=d.get('creation_timestamp', None),
-                   current_stage=d.get('current_stage', None),
                    description=d.get('description', None),
                    last_updated_timestamp=d.get('last_updated_timestamp', None),
+                   latest_versions=_repeated(d, 'latest_versions', ModelVersion),
                    name=d.get('name', None),
-                   run_id=d.get('run_id', None),
-                   run_link=d.get('run_link', None),
-                   source=d.get('source', None),
-                   status=_enum(d, 'status', ModelVersionStatus),
-                   status_message=d.get('status_message', None),
-                   tags=_repeated(d, 'tags', ModelVersionTag),
-                   user_id=d.get('user_id', None),
-                   version=d.get('version', None))
+                   tags=_repeated(d, 'tags', ModelTag),
+                   user_id=d.get('user_id', None))
 
 
 @dataclass
-class ModelVersionDatabricks:
+class ModelDatabricks:
     creation_timestamp: int = None
-    current_stage: 'Stage' = None
     description: str = None
+    id: str = None
     last_updated_timestamp: int = None
+    latest_versions: 'List[ModelVersion]' = None
     name: str = None
     permission_level: 'PermissionLevel' = None
-    run_id: str = None
-    run_link: str = None
-    source: str = None
-    status: 'Status' = None
-    status_message: str = None
-    tags: 'List[ModelVersionTag]' = None
+    tags: 'List[ModelTag]' = None
     user_id: str = None
-    version: str = None
 
     def as_dict(self) -> dict:
         body = {}
         if self.creation_timestamp: body['creation_timestamp'] = self.creation_timestamp
-        if self.current_stage: body['current_stage'] = self.current_stage.value
         if self.description: body['description'] = self.description
+        if self.id: body['id'] = self.id
         if self.last_updated_timestamp: body['last_updated_timestamp'] = self.last_updated_timestamp
+        if self.latest_versions: body['latest_versions'] = [v.as_dict() for v in self.latest_versions]
         if self.name: body['name'] = self.name
         if self.permission_level: body['permission_level'] = self.permission_level.value
-        if self.run_id: body['run_id'] = self.run_id
-        if self.run_link: body['run_link'] = self.run_link
-        if self.source: body['source'] = self.source
-        if self.status: body['status'] = self.status.value
-        if self.status_message: body['status_message'] = self.status_message
         if self.tags: body['tags'] = [v.as_dict() for v in self.tags]
         if self.user_id: body['user_id'] = self.user_id
-        if self.version: body['version'] = self.version
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'ModelVersionDatabricks':
+    def from_dict(cls, d: Dict[str, any]) -> 'ModelDatabricks':
         return cls(creation_timestamp=d.get('creation_timestamp', None),
-                   current_stage=_enum(d, 'current_stage', Stage),
                    description=d.get('description', None),
+                   id=d.get('id', None),
                    last_updated_timestamp=d.get('last_updated_timestamp', None),
+                   latest_versions=_repeated(d, 'latest_versions', ModelVersion),
                    name=d.get('name', None),
                    permission_level=_enum(d, 'permission_level', PermissionLevel),
-                   run_id=d.get('run_id', None),
-                   run_link=d.get('run_link', None),
-                   source=d.get('source', None),
-                   status=_enum(d, 'status', Status),
-                   status_message=d.get('status_message', None),
-                   tags=_repeated(d, 'tags', ModelVersionTag),
-                   user_id=d.get('user_id', None),
-                   version=d.get('version', None))
-
-
-class ModelVersionStatus(Enum):
-    """Current status of `model_version`"""
-
-    FAILED_REGISTRATION = 'FAILED_REGISTRATION'
-    PENDING_REGISTRATION = 'PENDING_REGISTRATION'
-    READY = 'READY'
-
-
-@dataclass
-class ModelVersionTag:
-    key: str = None
-    value: str = None
-
-    def as_dict(self) -> dict:
-        body = {}
-        if self.key: body['key'] = self.key
-        if self.value: body['value'] = self.value
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'ModelVersionTag':
-        return cls(key=d.get('key', None), value=d.get('value', None))
+                   tags=_repeated(d, 'tags', ModelTag),
+                   user_id=d.get('user_id', None))
 
 
 @dataclass
-class Param:
+class ModelTag:
     key: str = None
     value: str = None
 
@@ -1196,93 +1149,139 @@ class Param:
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'Param':
+    def from_dict(cls, d: Dict[str, any]) -> 'ModelTag':
         return cls(key=d.get('key', None), value=d.get('value', None))
 
 
-class PermissionLevel(Enum):
-    """Permission level of the requesting user on the object. For what is allowed at each level, see
-    [MLflow Model permissions](..)."""
-
-    CAN_EDIT = 'CAN_EDIT'
-    CAN_MANAGE = 'CAN_MANAGE'
-    CAN_MANAGE_PRODUCTION_VERSIONS = 'CAN_MANAGE_PRODUCTION_VERSIONS'
-    CAN_MANAGE_STAGING_VERSIONS = 'CAN_MANAGE_STAGING_VERSIONS'
-    CAN_READ = 'CAN_READ'
-
-
 @dataclass
-class RegisteredModel:
+class ModelVersion:
     creation_timestamp: int = None
+    current_stage: str = None
     description: str = None
     last_updated_timestamp: int = None
-    latest_versions: 'List[ModelVersion]' = None
     name: str = None
-    tags: 'List[RegisteredModelTag]' = None
+    run_id: str = None
+    run_link: str = None
+    source: str = None
+    status: 'ModelVersionStatus' = None
+    status_message: str = None
+    tags: 'List[ModelVersionTag]' = None
     user_id: str = None
+    version: str = None
 
     def as_dict(self) -> dict:
         body = {}
         if self.creation_timestamp: body['creation_timestamp'] = self.creation_timestamp
+        if self.current_stage: body['current_stage'] = self.current_stage
         if self.description: body['description'] = self.description
         if self.last_updated_timestamp: body['last_updated_timestamp'] = self.last_updated_timestamp
-        if self.latest_versions: body['latest_versions'] = [v.as_dict() for v in self.latest_versions]
         if self.name: body['name'] = self.name
+        if self.run_id: body['run_id'] = self.run_id
+        if self.run_link: body['run_link'] = self.run_link
+        if self.source: body['source'] = self.source
+        if self.status: body['status'] = self.status.value
+        if self.status_message: body['status_message'] = self.status_message
         if self.tags: body['tags'] = [v.as_dict() for v in self.tags]
         if self.user_id: body['user_id'] = self.user_id
+        if self.version: body['version'] = self.version
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'RegisteredModel':
+    def from_dict(cls, d: Dict[str, any]) -> 'ModelVersion':
         return cls(creation_timestamp=d.get('creation_timestamp', None),
+                   current_stage=d.get('current_stage', None),
                    description=d.get('description', None),
                    last_updated_timestamp=d.get('last_updated_timestamp', None),
-                   latest_versions=_repeated(d, 'latest_versions', ModelVersion),
                    name=d.get('name', None),
-                   tags=_repeated(d, 'tags', RegisteredModelTag),
-                   user_id=d.get('user_id', None))
+                   run_id=d.get('run_id', None),
+                   run_link=d.get('run_link', None),
+                   source=d.get('source', None),
+                   status=_enum(d, 'status', ModelVersionStatus),
+                   status_message=d.get('status_message', None),
+                   tags=_repeated(d, 'tags', ModelVersionTag),
+                   user_id=d.get('user_id', None),
+                   version=d.get('version', None))
 
 
 @dataclass
-class RegisteredModelDatabricks:
+class ModelVersionDatabricks:
     creation_timestamp: int = None
+    current_stage: 'Stage' = None
     description: str = None
-    id: str = None
     last_updated_timestamp: int = None
-    latest_versions: 'List[ModelVersion]' = None
     name: str = None
     permission_level: 'PermissionLevel' = None
-    tags: 'List[RegisteredModelTag]' = None
+    run_id: str = None
+    run_link: str = None
+    source: str = None
+    status: 'Status' = None
+    status_message: str = None
+    tags: 'List[ModelVersionTag]' = None
     user_id: str = None
+    version: str = None
 
     def as_dict(self) -> dict:
         body = {}
         if self.creation_timestamp: body['creation_timestamp'] = self.creation_timestamp
+        if self.current_stage: body['current_stage'] = self.current_stage.value
         if self.description: body['description'] = self.description
-        if self.id: body['id'] = self.id
         if self.last_updated_timestamp: body['last_updated_timestamp'] = self.last_updated_timestamp
-        if self.latest_versions: body['latest_versions'] = [v.as_dict() for v in self.latest_versions]
         if self.name: body['name'] = self.name
         if self.permission_level: body['permission_level'] = self.permission_level.value
+        if self.run_id: body['run_id'] = self.run_id
+        if self.run_link: body['run_link'] = self.run_link
+        if self.source: body['source'] = self.source
+        if self.status: body['status'] = self.status.value
+        if self.status_message: body['status_message'] = self.status_message
         if self.tags: body['tags'] = [v.as_dict() for v in self.tags]
         if self.user_id: body['user_id'] = self.user_id
+        if self.version: body['version'] = self.version
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'RegisteredModelDatabricks':
+    def from_dict(cls, d: Dict[str, any]) -> 'ModelVersionDatabricks':
         return cls(creation_timestamp=d.get('creation_timestamp', None),
+                   current_stage=_enum(d, 'current_stage', Stage),
                    description=d.get('description', None),
-                   id=d.get('id', None),
                    last_updated_timestamp=d.get('last_updated_timestamp', None),
-                   latest_versions=_repeated(d, 'latest_versions', ModelVersion),
                    name=d.get('name', None),
                    permission_level=_enum(d, 'permission_level', PermissionLevel),
-                   tags=_repeated(d, 'tags', RegisteredModelTag),
-                   user_id=d.get('user_id', None))
+                   run_id=d.get('run_id', None),
+                   run_link=d.get('run_link', None),
+                   source=d.get('source', None),
+                   status=_enum(d, 'status', Status),
+                   status_message=d.get('status_message', None),
+                   tags=_repeated(d, 'tags', ModelVersionTag),
+                   user_id=d.get('user_id', None),
+                   version=d.get('version', None))
+
+
+class ModelVersionStatus(Enum):
+    """Current status of `model_version`"""
+
+    FAILED_REGISTRATION = 'FAILED_REGISTRATION'
+    PENDING_REGISTRATION = 'PENDING_REGISTRATION'
+    READY = 'READY'
+
+
+@dataclass
+class ModelVersionTag:
+    key: str = None
+    value: str = None
+
+    def as_dict(self) -> dict:
+        body = {}
+        if self.key: body['key'] = self.key
+        if self.value: body['value'] = self.value
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> 'ModelVersionTag':
+        return cls(key=d.get('key', None), value=d.get('value', None))
 
 
 @dataclass
-class RegisteredModelTag:
+class Param:
     key: str = None
     value: str = None
 
@@ -1293,10 +1292,21 @@ class RegisteredModelTag:
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'RegisteredModelTag':
+    def from_dict(cls, d: Dict[str, any]) -> 'Param':
         return cls(key=d.get('key', None), value=d.get('value', None))
 
 
+class PermissionLevel(Enum):
+    """Permission level of the requesting user on the object. For what is allowed at each level, see
+    [MLflow Model permissions](..)."""
+
+    CAN_EDIT = 'CAN_EDIT'
+    CAN_MANAGE = 'CAN_MANAGE'
+    CAN_MANAGE_PRODUCTION_VERSIONS = 'CAN_MANAGE_PRODUCTION_VERSIONS'
+    CAN_MANAGE_STAGING_VERSIONS = 'CAN_MANAGE_STAGING_VERSIONS'
+    CAN_READ = 'CAN_READ'
+
+
 @dataclass
 class RegistryWebhook:
     creation_timestamp: int = None
@@ -1359,20 +1369,6 @@ class RegistryWebhookStatus(Enum):
     TEST_MODE = 'TEST_MODE'
 
 
-@dataclass
-class RejectResponse:
-    activity: 'Activity' = None
-
-    def as_dict(self) -> dict:
-        body = {}
-        if self.activity: body['activity'] = self.activity.as_dict()
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'RejectResponse':
-        return cls(activity=_from_dict(d, 'activity', Activity))
-
-
 @dataclass
 class RejectTransitionRequest:
     name: str
@@ -1397,7 +1393,21 @@ class RejectTransitionRequest:
 
 
 @dataclass
-class RenameRegisteredModelRequest:
+class RejectTransitionRequestResponse:
+    activity: 'Activity' = None
+
+    def as_dict(self) -> dict:
+        body = {}
+        if self.activity: body['activity'] = self.activity.as_dict()
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> 'RejectTransitionRequestResponse':
+        return cls(activity=_from_dict(d, 'activity', Activity))
+
+
+@dataclass
+class RenameModelRequest:
     name: str
     new_name: str = None
 
@@ -1408,13 +1418,13 @@ class RenameRegisteredModelRequest:
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'RenameRegisteredModelRequest':
+    def from_dict(cls, d: Dict[str, any]) -> 'RenameModelRequest':
         return cls(name=d.get('name', None), new_name=d.get('new_name', None))
 
 
 @dataclass
-class RenameRegisteredModelResponse:
-    registered_model: 'RegisteredModel' = None
+class RenameModelResponse:
+    registered_model: 'Model' = None
 
     def as_dict(self) -> dict:
         body = {}
@@ -1422,8 +1432,8 @@ class RenameRegisteredModelResponse:
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'RenameRegisteredModelResponse':
-        return cls(registered_model=_from_dict(d, 'registered_model', RegisteredModel))
+    def from_dict(cls, d: Dict[str, any]) -> 'RenameModelResponse':
+        return cls(registered_model=_from_dict(d, 'registered_model', Model))
 
 
 @dataclass
@@ -1634,7 +1644,7 @@ class SearchModelVersionsResponse:
 
 
 @dataclass
-class SearchRegisteredModelsRequest:
+class SearchModelsRequest:
     """Search models"""
 
     filter: str = None
@@ -1644,9 +1654,9 @@ class SearchRegisteredModelsRequest:
 
 
 @dataclass
-class SearchRegisteredModelsResponse:
+class SearchModelsResponse:
     next_page_token: str = None
-    registered_models: 'List[RegisteredModel]' = None
+    registered_models: 'List[Model]' = None
 
     def as_dict(self) -> dict:
         body = {}
@@ -1655,9 +1665,9 @@ class SearchRegisteredModelsResponse:
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'SearchRegisteredModelsResponse':
+    def from_dict(cls, d: Dict[str, any]) -> 'SearchModelsResponse':
         return cls(next_page_token=d.get('next_page_token', None),
-                   registered_models=_repeated(d, 'registered_models', RegisteredModel))
+                   registered_models=_repeated(d, 'registered_models', Model))
 
 
 @dataclass
@@ -1734,9 +1744,8 @@ class SetExperimentTag:
 
 
 @dataclass
-class SetModelVersionTagRequest:
+class SetModelTagRequest:
     name: str
-    version: str
     key: str
     value: str
 
@@ -1745,20 +1754,17 @@ class SetModelVersionTagRequest:
         if self.key: body['key'] = self.key
         if self.name: body['name'] = self.name
         if self.value: body['value'] = self.value
-        if self.version: body['version'] = self.version
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'SetModelVersionTagRequest':
-        return cls(key=d.get('key', None),
-                   name=d.get('name', None),
-                   value=d.get('value', None),
-                   version=d.get('version', None))
+    def from_dict(cls, d: Dict[str, any]) -> 'SetModelTagRequest':
+        return cls(key=d.get('key', None), name=d.get('name', None), value=d.get('value', None))
 
 
 @dataclass
-class SetRegisteredModelTagRequest:
+class SetModelVersionTagRequest:
     name: str
+    version: str
     key: str
     value: str
 
@@ -1767,11 +1773,15 @@ class SetRegisteredModelTagRequest:
         if self.key: body['key'] = self.key
         if self.name: body['name'] = self.name
         if self.value: body['value'] = self.value
+        if self.version: body['version'] = self.version
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'SetRegisteredModelTagRequest':
-        return cls(key=d.get('key', None), name=d.get('name', None), value=d.get('value', None))
+    def from_dict(cls, d: Dict[str, any]) -> 'SetModelVersionTagRequest':
+        return cls(key=d.get('key', None),
+                   name=d.get('name', None),
+                   value=d.get('value', None),
+                   version=d.get('version', None))
 
 
 @dataclass
@@ -1862,29 +1872,6 @@ class TestRegistryWebhookResponse:
         return cls(webhook=_from_dict(d, 'webhook', TestRegistryWebhook))
 
 
-@dataclass
-class TransitionModelVersionStage:
-    name: str
-    version: str
-    stage: str
-    archive_existing_versions: bool
-
-    def as_dict(self) -> dict:
-        body = {}
-        if self.archive_existing_versions: body['archive_existing_versions'] = self.archive_existing_versions
-        if self.name: body['name'] = self.name
-        if self.stage: body['stage'] = self.stage
-        if self.version: body['version'] = self.version
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'TransitionModelVersionStage':
-        return cls(archive_existing_versions=d.get('archive_existing_versions', None),
-                   name=d.get('name', None),
-                   stage=d.get('stage', None),
-                   version=d.get('version', None))
-
-
 @dataclass
 class TransitionModelVersionStageDatabricks:
     name: str
@@ -1911,20 +1898,6 @@ class TransitionModelVersionStageDatabricks:
                    version=d.get('version', None))
 
 
-@dataclass
-class TransitionModelVersionStageResponse:
-    model_version: 'ModelVersion' = None
-
-    def as_dict(self) -> dict:
-        body = {}
-        if self.model_version: body['model_version'] = self.model_version.as_dict()
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'TransitionModelVersionStageResponse':
-        return cls(model_version=_from_dict(d, 'model_version', ModelVersion))
-
-
 @dataclass
 class TransitionRequest:
     """Transition request details."""
@@ -1983,6 +1956,20 @@ class UpdateComment:
         return cls(comment=d.get('comment', None), id=d.get('id', None))
 
 
+@dataclass
+class UpdateCommentResponse:
+    comment: 'CommentObject' = None
+
+    def as_dict(self) -> dict:
+        body = {}
+        if self.comment: body['comment'] = self.comment.as_dict()
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> 'UpdateCommentResponse':
+        return cls(comment=_from_dict(d, 'comment', CommentObject))
+
+
 @dataclass
 class UpdateExperiment:
     experiment_id: str
@@ -2000,39 +1987,39 @@ class UpdateExperiment:
 
 
 @dataclass
-class UpdateModelVersionRequest:
+class UpdateModelRequest:
     name: str
-    version: str
     description: str = None
 
     def as_dict(self) -> dict:
         body = {}
         if self.description: body['description'] = self.description
         if self.name: body['name'] = self.name
-        if self.version: body['version'] = self.version
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'UpdateModelVersionRequest':
-        return cls(description=d.get('description', None),
-                   name=d.get('name', None),
-                   version=d.get('version', None))
+    def from_dict(cls, d: Dict[str, any]) -> 'UpdateModelRequest':
+        return cls(description=d.get('description', None), name=d.get('name', None))
 
 
 @dataclass
-class UpdateRegisteredModelRequest:
+class UpdateModelVersionRequest:
     name: str
+    version: str
     description: str = None
 
     def as_dict(self) -> dict:
         body = {}
         if self.description: body['description'] = self.description
         if self.name: body['name'] = self.name
+        if self.version: body['version'] = self.version
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'UpdateRegisteredModelRequest':
-        return cls(description=d.get('description', None), name=d.get('name', None))
+    def from_dict(cls, d: Dict[str, any]) -> 'UpdateModelVersionRequest':
+        return cls(description=d.get('description', None),
+                   name=d.get('name', None),
+                   version=d.get('version', None))
 
 
 @dataclass
@@ -2064,20 +2051,6 @@ class UpdateRegistryWebhook:
                    status=_enum(d, 'status', RegistryWebhookStatus))
 
 
-@dataclass
-class UpdateResponse:
-    comment: 'CommentObject' = None
-
-    def as_dict(self) -> dict:
-        body = {}
-        if self.comment: body['comment'] = self.comment.as_dict()
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> 'UpdateResponse':
-        return cls(comment=_from_dict(d, 'comment', CommentObject))
-
-
 @dataclass
 class UpdateRun:
     end_time: int = None
@@ -2130,12 +2103,12 @@ class ExperimentsAPI:
     def __init__(self, api_client):
         self._api = api_client
 
-    def create(self,
-               name: str,
-               *,
-               artifact_location: str = None,
-               tags: List[ExperimentTag] = None,
-               **kwargs) -> CreateExperimentResponse:
+    def create_experiment(self,
+                          name: str,
+                          *,
+                          artifact_location: str = None,
+                          tags: List[ExperimentTag] = None,
+                          **kwargs) -> CreateExperimentResponse:
         """Create experiment.
         
         Creates an experiment with a name. Returns the ID of the newly created experiment. Validates that
@@ -2151,7 +2124,30 @@ class ExperimentsAPI:
         json = self._api.do('POST', '/api/2.0/mlflow/experiments/create', body=body)
         return CreateExperimentResponse.from_dict(json)
 
-    def delete(self, experiment_id: str, **kwargs):
+    def create_run(self,
+                   *,
+                   experiment_id: str = None,
+                   start_time: int = None,
+                   tags: List[RunTag] = None,
+                   user_id: str = None,
+                   **kwargs) -> CreateRunResponse:
+        """Create a run.
+        
+        Creates a new run within an experiment. A run is usually a single execution of a machine learning or
+        data ETL pipeline. MLflow uses runs to track the `mlflowParam`, `mlflowMetric` and `mlflowRunTag`
+        associated with a single execution."""
+        request = kwargs.get('request', None)
+        if not request: # request is not given through keyed args
+            request = CreateRun(experiment_id=experiment_id,
+                                start_time=start_time,
+                                tags=tags,
+                                user_id=user_id)
+        body = request.as_dict()
+
+        json = self._api.do('POST', '/api/2.0/mlflow/runs/create', body=body)
+        return CreateRunResponse.from_dict(json)
+
+    def delete_experiment(self, experiment_id: str, **kwargs):
         """Delete an experiment.
         
         Marks an experiment and associated metadata, runs, metrics, params, and tags for deletion. If the
@@ -2162,19 +2158,26 @@ class ExperimentsAPI:
         body = request.as_dict()
         self._api.do('POST', '/api/2.0/mlflow/experiments/delete', body=body)
 
-    def get(self, experiment_id: str, **kwargs) -> Experiment:
-        """Get an experiment.
+    def delete_run(self, run_id: str, **kwargs):
+        """Delete a run.
         
-        Gets metadata for an experiment. This method works on deleted experiments."""
+        Marks a run for deletion."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = GetExperimentRequest(experiment_id=experiment_id)
-
-        query = {}
-        if experiment_id: query['experiment_id'] = request.experiment_id
+            request = DeleteRun(run_id=run_id)
+        body = request.as_dict()
+        self._api.do('POST', '/api/2.0/mlflow/runs/delete', body=body)
 
-        json = self._api.do('GET', '/api/2.0/mlflow/experiments/get', query=query)
-        return Experiment.from_dict(json)
+    def delete_tag(self, run_id: str, key: str, **kwargs):
+        """Delete a tag.
+        
+        Deletes a tag on a run. Tags are run metadata that can be updated during a run and after a run
+        completes."""
+        request = kwargs.get('request', None)
+        if not request: # request is not given through keyed args
+            request = DeleteTag(key=key, run_id=run_id)
+        body = request.as_dict()
+        self._api.do('POST', '/api/2.0/mlflow/runs/delete-tag', body=body)
 
     def get_by_name(self, experiment_name: str, **kwargs) -> GetExperimentByNameResponse:
         """Get metadata.
@@ -2196,12 +2199,104 @@ class ExperimentsAPI:
         json = self._api.do('GET', '/api/2.0/mlflow/experiments/get-by-name', query=query)
         return GetExperimentByNameResponse.from_dict(json)
 
-    def list(self,
-             *,
-             max_results: int = None,
-             page_token: str = None,
-             view_type: str = None,
-             **kwargs) -> Iterator[Experiment]:
+    def get_experiment(self, experiment_id: str, **kwargs) -> Experiment:
+        """Get an experiment.
+        
+        Gets metadata for an experiment. This method works on deleted experiments."""
+        request = kwargs.get('request', None)
+        if not request: # request is not given through keyed args
+            request = GetExperimentRequest(experiment_id=experiment_id)
+
+        query = {}
+        if experiment_id: query['experiment_id'] = request.experiment_id
+
+        json = self._api.do('GET', '/api/2.0/mlflow/experiments/get', query=query)
+        return Experiment.from_dict(json)
+
+    def get_history(self,
+                    metric_key: str,
+                    *,
+                    max_results: int = None,
+                    page_token: str = None,
+                    run_id: str = None,
+                    run_uuid: str = None,
+                    **kwargs) -> GetMetricHistoryResponse:
+        """Get history of a given metric within a run.
+        
+        Gets a list of all values for the specified metric for a given run."""
+        request = kwargs.get('request', None)
+        if not request: # request is not given through keyed args
+            request = GetHistoryRequest(max_results=max_results,
+                                        metric_key=metric_key,
+                                        page_token=page_token,
+                                        run_id=run_id,
+                                        run_uuid=run_uuid)
+
+        query = {}
+        if max_results: query['max_results'] = request.max_results
+        if metric_key: query['metric_key'] = request.metric_key
+        if page_token: query['page_token'] = request.page_token
+        if run_id: query['run_id'] = request.run_id
+        if run_uuid: query['run_uuid'] = request.run_uuid
+
+        json = self._api.do('GET', '/api/2.0/mlflow/metrics/get-history', query=query)
+        return GetMetricHistoryResponse.from_dict(json)
+
+    def get_run(self, run_id: str, *, run_uuid: str = None, **kwargs) -> GetRunResponse:
+        """Get a run.
+        
+        "Gets the metadata, metrics, params, and tags for a run. In the case where multiple metrics with the
+        same key are logged for a run, return only the value with the latest timestamp.
+        
+        If there are multiple values with the latest timestamp, return the maximum of these values."""
+        request = kwargs.get('request', None)
+        if not request: # request is not given through keyed args
+            request = GetRunRequest(run_id=run_id, run_uuid=run_uuid)
+
+        query = {}
+        if run_id: query['run_id'] = request.run_id
+        if run_uuid: query['run_uuid'] = request.run_uuid
+
+        json = self._api.do('GET', '/api/2.0/mlflow/runs/get', query=query)
+        return GetRunResponse.from_dict(json)
+
+    def list_artifacts(self,
+                       *,
+                       page_token: str = None,
+                       path: str = None,
+                       run_id: str = None,
+                       run_uuid: str = None,
+                       **kwargs) -> Iterator[FileInfo]:
+        """Get all artifacts.
+        
+        List artifacts for a run. Takes an optional `artifact_path` prefix. If it is specified, the response
+        contains only artifacts with the specified prefix.","""
+        request = kwargs.get('request', None)
+        if not request: # request is not given through keyed args
+            request = ListArtifactsRequest(page_token=page_token, path=path, run_id=run_id, run_uuid=run_uuid)
+
+        query = {}
+        if page_token: query['page_token'] = request.page_token
+        if path: query['path'] = request.path
+        if run_id: query['run_id'] = request.run_id
+        if run_uuid: query['run_uuid'] = request.run_uuid
+
+        while True:
+            json = self._api.do('GET', '/api/2.0/mlflow/artifacts/list', query=query)
+            if 'files' not in json or not json['files']:
+                return
+            for v in json['files']:
+                yield FileInfo.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 list_experiments(self,
+                         *,
+                         max_results: int = None,
+                         page_token: str = None,
+                         view_type: str = None,
+                         **kwargs) -> Iterator[Experiment]:
         """List experiments.
         
         Gets a list of all experiments."""
@@ -2226,7 +2321,103 @@ class ExperimentsAPI:
                 return
             query['page_token'] = json['next_page_token']
 
-    def restore(self, experiment_id: str, **kwargs):
+    def log_batch(self,
+                  *,
+                  metrics: List[Metric] = None,
+                  params: List[Param] = None,
+                  run_id: str = None,
+                  tags: List[RunTag] = None,
+                  **kwargs):
+        """Log a batch.
+        
+        Logs a batch of metrics, params, and tags for a run. If any data failed to be persisted, the server
+        will respond with an error (non-200 status code).
+        
+        In case of error (due to internal server error or an invalid request), partial data may be written.
+        
+        You can write metrics, params, and tags in interleaving fashion, but within a given entity type are
+        guaranteed to follow the order specified in the request body.
+        
+        The overwrite behavior for metrics, params, and tags is as follows:
+        
+        * Metrics: metric values are never overwritten. Logging a metric (key, value, timestamp) appends to
+        the set of values for the metric with the provided key.
+        
+        * Tags: tag values can be overwritten by successive writes to the same tag key. That is, if multiple
+        tag values with the same key are provided in the same API request, the last-provided tag value is
+        written. Logging the same tag (key, value) is permitted. Specifically, logging a tag is idempotent.
+        
+        * Parameters: once written, param values cannot be changed (attempting to overwrite a param value will
+        result in an error). However, logging the same param (key, value) is permitted. Specifically, logging
+        a param is idempotent.
+        
+        Request Limits ------------------------------- A single JSON-serialized API request may be up to 1 MB
+        in size and contain:
+        
+        * No more than 1000 metrics, params, and tags in total * Up to 1000 metrics - Up to 100 params * Up to
+        100 tags
+        
+        For example, a valid request might contain 900 metrics, 50 params, and 50 tags, but logging 900
+        metrics, 50 params, and 51 tags is invalid.
+        
+        The following limits also apply to metric, param, and tag keys and values:
+        
+        * Metric keyes, param keys, and tag keys can be up to 250 characters in length * Parameter and tag
+        values can be up to 250 characters in length"""
+        request = kwargs.get('request', None)
+        if not request: # request is not given through keyed args
+            request = LogBatch(metrics=metrics, params=params, run_id=run_id, tags=tags)
+        body = request.as_dict()
+        self._api.do('POST', '/api/2.0/mlflow/runs/log-batch', body=body)
+
+    def log_metric(self,
+                   key: str,
+                   value: float,
+                   timestamp: int,
+                   *,
+                   run_id: str = None,
+                   run_uuid: str = None,
+                   step: int = None,
+                   **kwargs):
+        """Log a metric.
+        
+        Logs a metric for a run. A metric is a key-value pair (string key, float value) with an associated
+        timestamp. Examples include the various metrics that represent ML model accuracy. A metric can be
+        logged multiple times."""
+        request = kwargs.get('request', None)
+        if not request: # request is not given through keyed args
+            request = LogMetric(key=key,
+                                run_id=run_id,
+                                run_uuid=run_uuid,
+                                step=step,
+                                timestamp=timestamp,
+                                value=value)
+        body = request.as_dict()
+        self._api.do('POST', '/api/2.0/mlflow/runs/log-metric', body=body)
+
+    def log_model(self, *, model_json: str = None, run_id: str = None, **kwargs):
+        """Log a model.
+        
+        **NOTE:** Experimental: This API may change or be removed in a future release without warning."""
+        request = kwargs.get('request', None)
+        if not request: # request is not given through keyed args
+            request = LogModel(model_json=model_json, run_id=run_id)
+        body = request.as_dict()
+        self._api.do('POST', '/api/2.0/mlflow/runs/log-model', body=body)
+
+    def log_param(self, key: str, value: str, *, run_id: str = None, run_uuid: str = None, **kwargs):
+        """Log a param.
+        
+        Logs a param used for a run. A param is a key-value pair (string key, string value). Examples include
+        hyperparameters used for ML model training and constant dates and values used in an ETL pipeline. A
+        param can be logged only once for a run."""
+        request = kwargs.get('request', None)
+        if not request: # request is not given through keyed args
+            request = LogParam(key=key, run_id=run_id, run_uuid=run_uuid, value=value)
+        body = request.as_dict()
+        self._api.do('POST', '/api/2.0/mlflow/runs/log-parameter', body=body)
+
+    def restore_experiment(self, experiment_id: str, **kwargs):
         """Restores an experiment.
         
         "Restore an experiment marked for deletion. This also restores associated metadata, runs, metrics,
@@ -2240,14 +2431,24 @@ class ExperimentsAPI:
         body = request.as_dict()
         self._api.do('POST', '/api/2.0/mlflow/experiments/restore', body=body)
 
-    def search(self,
-               *,
-               filter: str = None,
-               max_results: int = None,
-               order_by: List[str] = None,
-               page_token: str = None,
-               view_type: SearchExperimentsViewType = None,
-               **kwargs) -> Iterator[Experiment]:
+    def restore_run(self, run_id: str, **kwargs):
+        """Restore a run.
+        
+        Restores a deleted run."""
+        request = kwargs.get('request', None)
+        if not request: # request is not given through keyed args
+            request = RestoreRun(run_id=run_id)
+        body = request.as_dict()
+        self._api.do('POST', '/api/2.0/mlflow/runs/restore', body=body)
+
+    def search_experiments(self,
+                           *,
+                           filter: str = None,
+                           max_results: int = None,
+                           order_by: List[str] = None,
+                           page_token: str = None,
+                           view_type: SearchExperimentsViewType = None,
+                           **kwargs) -> Iterator[Experiment]:
         """Search experiments.
         
         Searches for experiments that satisfy specified search criteria."""
@@ -2270,463 +2471,260 @@ class ExperimentsAPI:
                 return
             body['page_token'] = json['next_page_token']
 
-    def set_experiment_tag(self, experiment_id: str, key: str, value: str, **kwargs):
-        """Set a tag.
+    def search_runs(self,
+                    *,
+                    experiment_ids: List[str] = None,
+                    filter: str = None,
+                    max_results: int = None,
+                    order_by: List[str] = None,
+                    page_token: str = None,
+                    run_view_type: SearchRunsRunViewType = None,
+                    **kwargs) -> Iterator[Run]:
+        """Search for runs.
         
-        Sets a tag on an experiment. Experiment tags are metadata that can be updated."""
+        Searches for runs that satisfy expressions.
+        
+        Search expressions can use `mlflowMetric` and `mlflowParam` keys.","""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = SetExperimentTag(experiment_id=experiment_id, key=key, value=value)
+            request = SearchRuns(experiment_ids=experiment_ids,
+                                 filter=filter,
+                                 max_results=max_results,
+                                 order_by=order_by,
+                                 page_token=page_token,
+                                 run_view_type=run_view_type)
         body = request.as_dict()
-        self._api.do('POST', '/api/2.0/mlflow/experiments/set-experiment-tag', body=body)
-
-    def update(self, experiment_id: str, *, new_name: str = None, **kwargs):
-        """Update an experiment.
-        
-        Updates experiment metadata."""
-        request = kwargs.get('request', None)
-        if not request: # request is not given through keyed args
-            request = UpdateExperiment(experiment_id=experiment_id, new_name=new_name)
-        body = request.as_dict()
-        self._api.do('POST', '/api/2.0/mlflow/experiments/update', body=body)
-
-
-class MLflowArtifactsAPI:
-
-    def __init__(self, api_client):
-        self._api = api_client
-
-    def list(self,
-             *,
-             page_token: str = None,
-             path: str = None,
-             run_id: str = None,
-             run_uuid: str = None,
-             **kwargs) -> Iterator[FileInfo]:
-        """Get all artifacts.
-        
-        List artifacts for a run. Takes an optional `artifact_path` prefix. If it is specified, the response
-        contains only artifacts with the specified prefix.","""
-        request = kwargs.get('request', None)
-        if not request: # request is not given through keyed args
-            request = ListArtifactsRequest(page_token=page_token, path=path, run_id=run_id, run_uuid=run_uuid)
-
-        query = {}
-        if page_token: query['page_token'] = request.page_token
-        if path: query['path'] = request.path
-        if run_id: query['run_id'] = request.run_id
-        if run_uuid: query['run_uuid'] = request.run_uuid
 
         while True:
-            json = self._api.do('GET', '/api/2.0/mlflow/artifacts/list', query=query)
-            if 'files' not in json or not json['files']:
+            json = self._api.do('POST', '/api/2.0/mlflow/runs/search', body=body)
+            if 'runs' not in json or not json['runs']:
                 return
-            for v in json['files']:
-                yield FileInfo.from_dict(v)
+            for v in json['runs']:
+                yield Run.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
-            query['page_token'] = json['next_page_token']
-
-
-class MLflowDatabricksAPI:
-    """These endpoints are modified versions of the MLflow API that accept additional input parameters or return
-    additional information."""
-
-    def __init__(self, api_client):
-        self._api = api_client
-
-    def get(self, name: str, **kwargs) -> GetResponse:
-        """Get model.
-        
-        Get the details of a model. This is a Databricks Workspace version of the [MLflow endpoint] that also
-        returns the model's Databricks Workspace ID and the permission level of the requesting user on the
-        model.
-        
-        [MLflow endpoint]: https://www.mlflow.org/docs/latest/rest-api.html#get-registeredmodel"""
-        request = kwargs.get('request', None)
-        if not request: # request is not given through keyed args
-            request = GetMLflowDatabrickRequest(name=name)
-
-        query = {}
-        if name: query['name'] = request.name
-
-        json = self._api.do('GET', '/api/2.0/mlflow/databricks/registered-models/get', query=query)
-        return GetResponse.from_dict(json)
+            body['page_token'] = json['next_page_token']
 
-    def transition_stage(self,
-                         name: str,
-                         version: str,
-                         stage: Stage,
-                         archive_existing_versions: bool,
-                         *,
-                         comment: str = None,
-                         **kwargs) -> TransitionStageResponse:
-        """Transition a stage.
-        
-        Transition a model version's stage. This is a Databricks Workspace version of the [MLflow endpoint]
-        that also accepts a comment associated with the transition to be recorded.",
+    def set_experiment_tag(self, experiment_id: str, key: str, value: str, **kwargs):
+        """Set a tag.
         
-        [MLflow endpoint]: https://www.mlflow.org/docs/latest/rest-api.html#transition-modelversion-stage"""
+        Sets a tag on an experiment. Experiment tags are metadata that can be updated."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = TransitionModelVersionStageDatabricks(
-                archive_existing_versions=archive_existing_versions,
-                comment=comment,
-                name=name,
-                stage=stage,
-                version=version)
+            request = SetExperimentTag(experiment_id=experiment_id, key=key, value=value)
         body = request.as_dict()
+        self._api.do('POST', '/api/2.0/mlflow/experiments/set-experiment-tag', body=body)
 
-        json = self._api.do('POST', '/api/2.0/mlflow/databricks/model-versions/transition-stage', body=body)
-        return TransitionStageResponse.from_dict(json)
-
-
-class MLflowMetricsAPI:
-
-    def __init__(self, api_client):
-        self._api = api_client
-
-    def get_history(self,
-                    metric_key: str,
-                    *,
-                    max_results: int = None,
-                    page_token: str = None,
-                    run_id: str = None,
-                    run_uuid: str = None,
-                    **kwargs) -> GetMetricHistoryResponse:
-        """Get history of a given metric within a run.
-        
-        Gets a list of all values for the specified metric for a given run."""
-        request = kwargs.get('request', None)
-        if not request: # request is not given through keyed args
-            request = GetHistoryRequest(max_results=max_results,
-                                        metric_key=metric_key,
-                                        page_token=page_token,
-                                        run_id=run_id,
-                                        run_uuid=run_uuid)
-
-        query = {}
-        if max_results: query['max_results'] = request.max_results
-        if metric_key: query['metric_key'] = request.metric_key
-        if page_token: query['page_token'] = request.page_token
-        if run_id: query['run_id'] = request.run_id
-        if run_uuid: query['run_uuid'] = request.run_uuid
-
-        json = self._api.do('GET', '/api/2.0/mlflow/metrics/get-history', query=query)
-        return GetMetricHistoryResponse.from_dict(json)
-
-
-class MLflowRunsAPI:
-
-    def __init__(self, api_client):
-        self._api = api_client
-
-    def create(self,
-               *,
-               experiment_id: str = None,
-               start_time: int = None,
-               tags: List[RunTag] = None,
-               user_id: str = None,
-               **kwargs) -> CreateRunResponse:
-        """Create a run.
+    def set_tag(self, key: str, value: str, *, run_id: str = None, run_uuid: str = None, **kwargs):
+        """Set a tag.
         
-        Creates a new run within an experiment. A run is usually a single execution of a machine learning or
-        data ETL pipeline. MLflow uses runs to track the `mlflowParam`, `mlflowMetric` and `mlflowRunTag`
-        associated with a single execution."""
+        Sets a tag on a run. Tags are run metadata that can be updated during a run and after a run completes."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = CreateRun(experiment_id=experiment_id,
-                                start_time=start_time,
-                                tags=tags,
-                                user_id=user_id)
+            request = SetTag(key=key, run_id=run_id, run_uuid=run_uuid, value=value)
         body = request.as_dict()
+        self._api.do('POST', '/api/2.0/mlflow/runs/set-tag', body=body)
 
-        json = self._api.do('POST', '/api/2.0/mlflow/runs/create', body=body)
-        return CreateRunResponse.from_dict(json)
-
-    def delete(self, run_id: str, **kwargs):
-        """Delete a run.
+    def update_experiment(self, experiment_id: str, *, new_name: str = None, **kwargs):
+        """Update an experiment.
         
-        Marks a run for deletion."""
+        Updates experiment metadata."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = DeleteRun(run_id=run_id)
+            request = UpdateExperiment(experiment_id=experiment_id, new_name=new_name)
         body = request.as_dict()
-        self._api.do('POST', '/api/2.0/mlflow/runs/delete', body=body)
+        self._api.do('POST', '/api/2.0/mlflow/experiments/update', body=body)
 
-    def delete_tag(self, run_id: str, key: str, **kwargs):
-        """Delete a tag.
+    def update_run(self,
+                   *,
+                   end_time: int = None,
+                   run_id: str = None,
+                   run_uuid: str = None,
+                   status: UpdateRunStatus = None,
+                   **kwargs) -> UpdateRunResponse:
+        """Update a run.
         
-        Deletes a tag on a run. Tags are run metadata that can be updated during a run and after a run
-        completes."""
+        Updates run metadata."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = DeleteTag(key=key, run_id=run_id)
+            request = UpdateRun(end_time=end_time, run_id=run_id, run_uuid=run_uuid, status=status)
         body = request.as_dict()
-        self._api.do('POST', '/api/2.0/mlflow/runs/delete-tag', body=body)
 
-    def get(self, run_id: str, *, run_uuid: str = None, **kwargs) -> GetRunResponse:
-        """Get a run.
-        
-        "Gets the metadata, metrics, params, and tags for a run. In the case where multiple metrics with the
-        same key are logged for a run, return only the value with the latest timestamp.
-        
-        If there are multiple values with the latest timestamp, return the maximum of these values."""
-        request = kwargs.get('request', None)
-        if not request: # request is not given through keyed args
-            request = GetRunRequest(run_id=run_id, run_uuid=run_uuid)
+        json = self._api.do('POST', '/api/2.0/mlflow/runs/update', body=body)
+        return UpdateRunResponse.from_dict(json)
 
-        query = {}
-        if run_id: query['run_id'] = request.run_id
-        if run_uuid: query['run_uuid'] = request.run_uuid
 
-        json = self._api.do('GET', '/api/2.0/mlflow/runs/get', query=query)
-        return GetRunResponse.from_dict(json)
+class ModelRegistryAPI:
 
-    def log_batch(self,
-                  *,
-                  metrics: List[Metric] = None,
-                  params: List[Param] = None,
-                  run_id: str = None,
-                  tags: List[RunTag] = None,
-                  **kwargs):
-        """Log a batch.
-        
-        Logs a batch of metrics, params, and tags for a run. If any data failed to be persisted, the server
-        will respond with an error (non-200 status code).
-        
-        In case of error (due to internal server error or an invalid request), partial data may be written.
-        
-        You can write metrics, params, and tags in interleaving fashion, but within a given entity type are
-        guaranteed to follow the order specified in the request body.
-        
-        The overwrite behavior for metrics, params, and tags is as follows:
-        
-        * Metrics: metric values are never overwritten. Logging a metric (key, value, timestamp) appends to
-        the set of values for the metric with the provided key.
-        
-        * Tags: tag values can be overwritten by successive writes to the same tag key. That is, if multiple
-        tag values with the same key are provided in the same API request, the last-provided tag value is
-        written. Logging the same tag (key, value) is permitted. Specifically, logging a tag is idempotent.
-        
-        * Parameters: once written, param values cannot be changed (attempting to overwrite a param value will
-        result in an error). However, logging the same param (key, value) is permitted. Specifically, logging
-        a param is idempotent.
-        
-        Request Limits ------------------------------- A single JSON-serialized API request may be up to 1 MB
-        in size and contain:
-        
-        * No more than 1000 metrics, params, and tags in total * Up to 1000 metrics - Up to 100 params * Up to
-        100 tags
-        
-        For example, a valid request might contain 900 metrics, 50 params, and 50 tags, but logging 900
-        metrics, 50 params, and 51 tags is invalid.
-        
-        The following limits also apply to metric, param, and tag keys and values:
-        
-        * Metric keyes, param keys, and tag keys can be up to 250 characters in length * Parameter and tag
-        values can be up to 250 characters in length"""
-        request = kwargs.get('request', None)
-        if not request: # request is not given through keyed args
-            request = LogBatch(metrics=metrics, params=params, run_id=run_id, tags=tags)
-        body = request.as_dict()
-        self._api.do('POST', '/api/2.0/mlflow/runs/log-batch', body=body)
+    def __init__(self, api_client):
+        self._api = api_client
 
-    def log_metric(self,
-                   key: str,
-                   value: float,
-                   timestamp: int,
-                   *,
-                   run_id: str = None,
-                   run_uuid: str = None,
-                   step: int = None,
-                   **kwargs):
-        """Log a metric.
+    def approve_transition_request(self,
+                                   name: str,
+                                   version: str,
+                                   stage: Stage,
+                                   archive_existing_versions: bool,
+                                   *,
+                                   comment: str = None,
+                                   **kwargs) -> ApproveTransitionRequestResponse:
+        """Approve transition request.
         
-        Logs a metric for a run. A metric is a key-value pair (string key, float value) with an associated
-        timestamp. Examples include the various metrics that represent ML model accuracy. A metric can be
-        logged multiple times."""
+        Approves a model version stage transition request."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = LogMetric(key=key,
-                                run_id=run_id,
-                                run_uuid=run_uuid,
-                                step=step,
-                                timestamp=timestamp,
-                                value=value)
+            request = ApproveTransitionRequest(archive_existing_versions=archive_existing_versions,
+                                               comment=comment,
+                                               name=name,
+                                               stage=stage,
+                                               version=version)
         body = request.as_dict()
-        self._api.do('POST', '/api/2.0/mlflow/runs/log-metric', body=body)
 
-    def log_model(self, *, model_json: str = None, run_id: str = None, **kwargs):
-        """Log a model.
-        
-        **NOTE:** Experimental: This API may change or be removed in a future release without warning."""
-        request = kwargs.get('request', None)
-        if not request: # request is not given through keyed args
-            request = LogModel(model_json=model_json, run_id=run_id)
-        body = request.as_dict()
-        self._api.do('POST', '/api/2.0/mlflow/runs/log-model', body=body)
+        json = self._api.do('POST', '/api/2.0/mlflow/transition-requests/approve', body=body)
+        return ApproveTransitionRequestResponse.from_dict(json)
 
-    def log_parameter(self, key: str, value: str, *, run_id: str = None, run_uuid: str = None, **kwargs):
-        """Log a param.
+    def create_comment(self, name: str, version: str, comment: str, **kwargs) -> CreateCommentResponse:
+        """Post a comment.
         
-        Logs a param used for a run. A param is a key-value pair (string key, string value). Examples include
-        hyperparameters used for ML model training and constant dates and values used in an ETL pipeline. A
-        param can be logged only once for a run."""
+        Posts a comment on a model version. A comment can be submitted either by a user or programmatically to
+        display relevant information about the model. For example, test results or deployment errors."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = LogParam(key=key, run_id=run_id, run_uuid=run_uuid, value=value)
+            request = CreateComment(comment=comment, name=name, version=version)
         body = request.as_dict()
-        self._api.do('POST', '/api/2.0/mlflow/runs/log-parameter', body=body)
 
-    def restore(self, run_id: str, **kwargs):
-        """Restore a run.
+        json = self._api.do('POST', '/api/2.0/mlflow/comments/create', body=body)
+        return CreateCommentResponse.from_dict(json)
+
+    def create_model(self,
+                     name: str,
+                     *,
+                     description: str = None,
+                     tags: List[ModelTag] = None,
+                     **kwargs) -> CreateModelResponse:
+        """Create a model.
         
-        Restores a deleted run."""
+        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."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = RestoreRun(run_id=run_id)
+            request = CreateModelRequest(description=description, name=name, tags=tags)
         body = request.as_dict()
-        self._api.do('POST', '/api/2.0/mlflow/runs/restore', body=body)
 
-    def search(self,
-               *,
-               experiment_ids: List[str] = None,
-               filter: str = None,
-               max_results: int = None,
-               order_by: List[str] = None,
-               page_token: str = None,
-               run_view_type: SearchRunsRunViewType = None,
-               **kwargs) -> Iterator[Run]:
-        """Search for runs.
-        
-        Searches for runs that satisfy expressions.
+        json = self._api.do('POST', '/api/2.0/mlflow/registered-models/create', body=body)
+        return CreateModelResponse.from_dict(json)
+
+    def create_model_version(self,
+                             name: str,
+                             source: str,
+                             *,
+                             description: str = None,
+                             run_id: str = None,
+                             run_link: str = None,
+                             tags: List[ModelVersionTag] = None,
+                             **kwargs) -> CreateModelVersionResponse:
+        """Create a model version.
         
-        Search expressions can use `mlflowMetric` and `mlflowParam` keys.","""
+        Creates a model version."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = SearchRuns(experiment_ids=experiment_ids,
-                                 filter=filter,
-                                 max_results=max_results,
-                                 order_by=order_by,
-                                 page_token=page_token,
-                                 run_view_type=run_view_type)
+            request = CreateModelVersionRequest(description=description,
+                                                name=name,
+                                                run_id=run_id,
+                                                run_link=run_link,
+                                                source=source,
+                                                tags=tags)
         body = request.as_dict()
 
-        while True:
-            json = self._api.do('POST', '/api/2.0/mlflow/runs/search', body=body)
-            if 'runs' not in json or not json['runs']:
-                return
-            for v in json['runs']:
-                yield Run.from_dict(v)
-            if 'next_page_token' not in json or not json['next_page_token']:
-                return
-            body['page_token'] = json['next_page_token']
+        json = self._api.do('POST', '/api/2.0/mlflow/model-versions/create', body=body)
+        return CreateModelVersionResponse.from_dict(json)
 
-    def set_tag(self, key: str, value: str, *, run_id: str = None, run_uuid: str = None, **kwargs):
-        """Set a tag.
+    def create_transition_request(self,
+                                  name: str,
+                                  version: str,
+                                  stage: Stage,
+                                  *,
+                                  comment: str = None,
+                                  **kwargs) -> CreateTransitionRequestResponse:
+        """Make a transition request.
         
-        Sets a tag on a run. Tags are run metadata that can be updated during a run and after a run completes."""
+        Creates a model version stage transition request."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = SetTag(key=key, run_id=run_id, run_uuid=run_uuid, value=value)
+            request = CreateTransitionRequest(comment=comment, name=name, stage=stage, version=version)
         body = request.as_dict()
-        self._api.do('POST', '/api/2.0/mlflow/runs/set-tag', body=body)
 
-    def update(self,
-               *,
-               end_time: int = None,
-               run_id: str = None,
-               run_uuid: str = None,
-               status: UpdateRunStatus = None,
-               **kwargs) -> UpdateRunResponse:
-        """Update a run.
+        json = self._api.do('POST', '/api/2.0/mlflow/transition-requests/create', body=body)
+        return CreateTransitionRequestResponse.from_dict(json)
+
+    def create_webhook(self,
+                       events: List[RegistryWebhookEvent],
+                       *,
+                       description: str = None,
+                       http_url_spec: HttpUrlSpec = None,
+                       job_spec: JobSpec = None,
+                       model_name: str = None,
+                       status: RegistryWebhookStatus = None,
+                       **kwargs) -> CreateWebhookResponse:
+        """Create a webhook.
         
-        Updates run metadata."""
-        request = kwargs.get('request', None)
-        if not request: # request is not given through keyed args
-            request = UpdateRun(end_time=end_time, run_id=run_id, run_uuid=run_uuid, status=status)
-        body = request.as_dict()
-
-        json = self._api.do('POST', '/api/2.0/mlflow/runs/update', body=body)
-        return UpdateRunResponse.from_dict(json)
-
-
-class ModelVersionCommentsAPI:
-
-    def __init__(self, api_client):
-        self._api = api_client
-
-    def create(self, name: str, version: str, comment: str, **kwargs) -> CreateResponse:
-        """Post a comment.
+        **NOTE**: This endpoint is in Public Preview.
         
-        Posts a comment on a model version. A comment can be submitted either by a user or programmatically to
-        display relevant information about the model. For example, test results or deployment errors."""
+        Creates a registry webhook."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = CreateComment(comment=comment, name=name, version=version)
+            request = CreateRegistryWebhook(description=description,
+                                            events=events,
+                                            http_url_spec=http_url_spec,
+                                            job_spec=job_spec,
+                                            model_name=model_name,
+                                            status=status)
         body = request.as_dict()
 
-        json = self._api.do('POST', '/api/2.0/mlflow/comments/create', body=body)
-        return CreateResponse.from_dict(json)
+        json = self._api.do('POST', '/api/2.0/mlflow/registry-webhooks/create', body=body)
+        return CreateWebhookResponse.from_dict(json)
 
-    def delete(self, id: str, **kwargs):
+    def delete_comment(self, id: str, **kwargs):
         """Delete a comment.
         
         Deletes a comment on a model version."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = DeleteModelVersionCommentRequest(id=id)
+            request = DeleteCommentRequest(id=id)
 
         query = {}
         if id: query['id'] = request.id
 
         self._api.do('DELETE', '/api/2.0/mlflow/comments/delete', query=query)
 
-    def update(self, id: str, comment: str, **kwargs) -> UpdateResponse:
-        """Update a comment.
+    def delete_model(self, name: str, **kwargs):
+        """Delete a model.
         
-        Post an edit to a comment on a model version."""
+        Deletes a registered model."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = UpdateComment(comment=comment, id=id)
-        body = request.as_dict()
-
-        json = self._api.do('POST', '/api/2.0/mlflow/comments/update', body=body)
-        return UpdateResponse.from_dict(json)
+            request = DeleteModelRequest(name=name)
 
+        query = {}
+        if name: query['name'] = request.name
 
-class ModelVersionsAPI:
-
-    def __init__(self, api_client):
-        self._api = api_client
+        self._api.do('DELETE', '/api/2.0/mlflow/registered-models/delete', query=query)
 
-    def create(self,
-               name: str,
-               source: str,
-               *,
-               description: str = None,
-               run_id: str = None,
-               run_link: str = None,
-               tags: List[ModelVersionTag] = None,
-               **kwargs) -> CreateModelVersionResponse:
-        """Create a model version.
+    def delete_model_tag(self, name: str, key: str, **kwargs):
+        """Delete a model tag.
         
-        Creates a model version."""
+        Deletes the tag for a registered model."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = CreateModelVersionRequest(description=description,
-                                                name=name,
-                                                run_id=run_id,
-                                                run_link=run_link,
-                                                source=source,
-                                                tags=tags)
-        body = request.as_dict()
+            request = DeleteModelTagRequest(key=key, name=name)
 
-        json = self._api.do('POST', '/api/2.0/mlflow/model-versions/create', body=body)
-        return CreateModelVersionResponse.from_dict(json)
+        query = {}
+        if key: query['key'] = request.key
+        if name: query['name'] = request.name
+
+        self._api.do('DELETE', '/api/2.0/mlflow/registered-models/delete-tag', query=query)
 
-    def delete(self, name: str, version: str, **kwargs):
+    def delete_model_version(self, name: str, version: str, **kwargs):
         """Delete a model version.
         
         Deletes a model version."""
@@ -2740,7 +2738,7 @@ class ModelVersionsAPI:
 
         self._api.do('DELETE', '/api/2.0/mlflow/model-versions/delete', query=query)
 
-    def delete_tag(self, name: str, version: str, key: str, **kwargs):
+    def delete_model_version_tag(self, name: str, version: str, key: str, **kwargs):
         """Delete a model version tag.
         
         Deletes a model version tag."""
@@ -2755,190 +2753,117 @@ class ModelVersionsAPI:
 
         self._api.do('DELETE', '/api/2.0/mlflow/model-versions/delete-tag', query=query)
 
-    def get(self, name: str, version: str, **kwargs) -> GetModelVersionResponse:
-        """Get a model version.
+    def delete_transition_request(self,
+                                  name: str,
+                                  version: str,
+                                  stage: str,
+                                  creator: str,
+                                  *,
+                                  comment: str = None,
+                                  **kwargs):
+        """Delete a ransition request.
         
-        Get a model version."""
+        Cancels a model version stage transition request."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = GetModelVersionRequest(name=name, version=version)
+            request = DeleteTransitionRequestRequest(comment=comment,
+                                                     creator=creator,
+                                                     name=name,
+                                                     stage=stage,
+                                                     version=version)
 
         query = {}
+        if comment: query['comment'] = request.comment
+        if creator: query['creator'] = request.creator
         if name: query['name'] = request.name
+        if stage: query['stage'] = request.stage
         if version: query['version'] = request.version
 
-        json = self._api.do('GET', '/api/2.0/mlflow/model-versions/get', query=query)
-        return GetModelVersionResponse.from_dict(json)
+        self._api.do('DELETE', '/api/2.0/mlflow/transition-requests/delete', query=query)
 
-    def get_download_uri(self, name: str, version: str, **kwargs) -> GetModelVersionDownloadUriResponse:
-        """Get a model version URI.
+    def delete_webhook(self, *, id: str = None, **kwargs):
+        """Delete a webhook.
         
-        Gets a URI to download the model version."""
-        request = kwargs.get('request', None)
-        if not request: # request is not given through keyed args
-            request = GetModelVersionDownloadUriRequest(name=name, version=version)
-
-        query = {}
-        if name: query['name'] = request.name
-        if version: query['version'] = request.version
-
-        json = self._api.do('GET', '/api/2.0/mlflow/model-versions/get-download-uri', query=query)
-        return GetModelVersionDownloadUriResponse.from_dict(json)
-
-    def search(self,
-               *,
-               filter: str = None,
-               max_results: int = None,
-               order_by: List[str] = None,
-               page_token: str = None,
-               **kwargs) -> Iterator[ModelVersion]:
-        """Searches model versions.
+        **NOTE:** This endpoint is in Public Preview.
         
-        Searches for specific model versions based on the supplied __filter__."""
+        Deletes a registry webhook."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = SearchModelVersionsRequest(filter=filter,
-                                                 max_results=max_results,
-                                                 order_by=order_by,
-                                                 page_token=page_token)
+            request = DeleteWebhookRequest(id=id)
 
         query = {}
-        if filter: query['filter'] = request.filter
-        if max_results: query['max_results'] = request.max_results
-        if order_by: query['order_by'] = [v for v in request.order_by]
-        if page_token: query['page_token'] = request.page_token
-
-        while True:
-            json = self._api.do('GET', '/api/2.0/mlflow/model-versions/search', query=query)
-            if 'model_versions' not in json or not json['model_versions']:
-                return
-            for v in json['model_versions']:
-                yield ModelVersion.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 set_tag(self, name: str, version: str, key: str, value: str, **kwargs):
-        """Set a version tag.
-        
-        Sets a model version tag."""
-        request = kwargs.get('request', None)
-        if not request: # request is not given through keyed args
-            request = SetModelVersionTagRequest(key=key, name=name, value=value, version=version)
-        body = request.as_dict()
-        self._api.do('POST', '/api/2.0/mlflow/model-versions/set-tag', body=body)
-
-    def transition_stage(self, name: str, version: str, stage: str, archive_existing_versions: bool,
-                         **kwargs) -> TransitionModelVersionStageResponse:
-        """Transition a stage.
-        
-        Transition to the next model stage."""
-        request = kwargs.get('request', None)
-        if not request: # request is not given through keyed args
-            request = TransitionModelVersionStage(archive_existing_versions=archive_existing_versions,
-                                                  name=name,
-                                                  stage=stage,
-                                                  version=version)
-        body = request.as_dict()
-
-        json = self._api.do('POST', '/api/2.0/mlflow/model-versions/transition-stage', body=body)
-        return TransitionModelVersionStageResponse.from_dict(json)
-
-    def update(self, name: str, version: str, *, description: str = None, **kwargs):
-        """Update model version.
-        
-        Updates the model version."""
-        request = kwargs.get('request', None)
-        if not request: # request is not given through keyed args
-            request = UpdateModelVersionRequest(description=description, name=name, version=version)
-        body = request.as_dict()
-        self._api.do('PATCH', '/api/2.0/mlflow/model-versions/update', body=body)
-
-
-class RegisteredModelsAPI:
+        if id: query['id'] = request.id
 
-    def __init__(self, api_client):
-        self._api = api_client
+        self._api.do('DELETE', '/api/2.0/mlflow/registry-webhooks/delete', query=query)
 
-    def create(self,
-               name: str,
-               *,
-               description: str = None,
-               tags: List[RegisteredModelTag] = None,
-               **kwargs) -> CreateRegisteredModelResponse:
-        """Create a model.
-        
-        Creates a new registered model with the name specified in the request body.
+    def get_latest_versions(self, name: str, *, stages: List[str] = None, **kwargs) -> Iterator[ModelVersion]:
+        """Get the latest version.
         
-        Throws `RESOURCE_ALREADY_EXISTS` if a registered model with the given name exists."""
+        Gets the latest version of a registered model."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = CreateRegisteredModelRequest(description=description, name=name, tags=tags)
+            request = GetLatestVersionsRequest(name=name, stages=stages)
         body = request.as_dict()
 
-        json = self._api.do('POST', '/api/2.0/mlflow/registered-models/create', body=body)
-        return CreateRegisteredModelResponse.from_dict(json)
+        json = self._api.do('POST', '/api/2.0/mlflow/registered-models/get-latest-versions', body=body)
+        return [ModelVersion.from_dict(v) for v in json.get('model_versions', [])]
 
-    def delete(self, name: str, **kwargs):
-        """Delete a model.
+    def get_model(self, name: str, **kwargs) -> GetModelResponse:
+        """Get model.
         
-        Deletes a registered model."""
-        request = kwargs.get('request', None)
-        if not request: # request is not given through keyed args
-            request = DeleteRegisteredModelRequest(name=name)
-
-        query = {}
-        if name: query['name'] = request.name
-
-        self._api.do('DELETE', '/api/2.0/mlflow/registered-models/delete', query=query)
-
-    def delete_tag(self, name: str, key: str, **kwargs):
-        """Delete a model tag.
+        Get the details of a model. This is a Databricks Workspace version of the [MLflow endpoint] that also
+        returns the model's Databricks Workspace ID and the permission level of the requesting user on the
+        model.
         
-        Deletes the tag for a registered model."""
+        [MLflow endpoint]: https://www.mlflow.org/docs/latest/rest-api.html#get-registeredmodel"""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = DeleteRegisteredModelTagRequest(key=key, name=name)
+            request = GetModelRequest(name=name)
 
         query = {}
-        if key: query['key'] = request.key
         if name: query['name'] = request.name
 
-        self._api.do('DELETE', '/api/2.0/mlflow/registered-models/delete-tag', query=query)
+        json = self._api.do('GET', '/api/2.0/mlflow/databricks/registered-models/get', query=query)
+        return GetModelResponse.from_dict(json)
 
-    def get(self, name: str, **kwargs) -> GetRegisteredModelResponse:
-        """Get a model.
+    def get_model_version(self, name: str, version: str, **kwargs) -> GetModelVersionResponse:
+        """Get a model version.
         
-        Gets the registered model that matches the specified ID."""
+        Get a model version."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = GetRegisteredModelRequest(name=name)
+            request = GetModelVersionRequest(name=name, version=version)
 
         query = {}
         if name: query['name'] = request.name
+        if version: query['version'] = request.version
 
-        json = self._api.do('GET', '/api/2.0/mlflow/registered-models/get', query=query)
-        return GetRegisteredModelResponse.from_dict(json)
+        json = self._api.do('GET', '/api/2.0/mlflow/model-versions/get', query=query)
+        return GetModelVersionResponse.from_dict(json)
 
-    def get_latest_versions(self, name: str, *, stages: List[str] = None, **kwargs) -> Iterator[ModelVersion]:
-        """Get the latest version.
+    def get_model_version_download_uri(self, name: str, version: str,
+                                       **kwargs) -> GetModelVersionDownloadUriResponse:
+        """Get a model version URI.
         
-        Gets the latest version of a registered model."""
+        Gets a URI to download the model version."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = GetLatestVersionsRequest(name=name, stages=stages)
-        body = request.as_dict()
+            request = GetModelVersionDownloadUriRequest(name=name, version=version)
 
-        json = self._api.do('POST', '/api/2.0/mlflow/registered-models/get-latest-versions', body=body)
-        return [ModelVersion.from_dict(v) for v in json.get('model_versions', [])]
+        query = {}
+        if name: query['name'] = request.name
+        if version: query['version'] = request.version
+
+        json = self._api.do('GET', '/api/2.0/mlflow/model-versions/get-download-uri', query=query)
+        return GetModelVersionDownloadUriResponse.from_dict(json)
 
-    def list(self, *, max_results: int = None, page_token: str = None, **kwargs) -> Iterator[RegisteredModel]:
+    def list_models(self, *, max_results: int = None, page_token: str = None, **kwargs) -> Iterator[Model]:
         """List models.
         
         Lists all available registered models, up to the limit specified in __max_results__."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = ListRegisteredModelsRequest(max_results=max_results, page_token=page_token)
+            request = ListModelsRequest(max_results=max_results, page_token=page_token)
 
         query = {}
         if max_results: query['max_results'] = request.max_results
@@ -2949,155 +2874,177 @@ class RegisteredModelsAPI:
             if 'registered_models' not in json or not json['registered_models']:
                 return
             for v in json['registered_models']:
-                yield RegisteredModel.from_dict(v)
+                yield Model.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 rename(self, name: str, *, new_name: str = None, **kwargs) -> RenameRegisteredModelResponse:
-        """Rename a model.
+    def list_transition_requests(self, name: str, version: str, **kwargs) -> Iterator[Activity]:
+        """List transition requests.
         
-        Renames a registered model."""
+        Gets a list of all open stage transition requests for the model version."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = RenameRegisteredModelRequest(name=name, new_name=new_name)
-        body = request.as_dict()
+            request = ListTransitionRequestsRequest(name=name, version=version)
 
-        json = self._api.do('POST', '/api/2.0/mlflow/registered-models/rename', body=body)
-        return RenameRegisteredModelResponse.from_dict(json)
-
-    def search(self,
-               *,
-               filter: str = None,
-               max_results: int = None,
-               order_by: List[str] = None,
-               page_token: str = None,
-               **kwargs) -> Iterator[RegisteredModel]:
-        """Search models.
+        query = {}
+        if name: query['name'] = request.name
+        if version: query['version'] = request.version
+
+        json = self._api.do('GET', '/api/2.0/mlflow/transition-requests/list', query=query)
+        return [Activity.from_dict(v) for v in json.get('requests', [])]
+
+    def list_webhooks(self,
+                      *,
+                      events: List[RegistryWebhookEvent] = None,
+                      model_name: str = None,
+                      page_token: str = None,
+                      **kwargs) -> Iterator[RegistryWebhook]:
+        """List registry webhooks.
         
-        Search for registered models based on the specified __filter__."""
+        **NOTE:** This endpoint is in Public Preview.
+        
+        Lists all registry webhooks."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = SearchRegisteredModelsRequest(filter=filter,
-                                                    max_results=max_results,
-                                                    order_by=order_by,
-                                                    page_token=page_token)
+            request = ListWebhooksRequest(events=events, model_name=model_name, page_token=page_token)
 
         query = {}
-        if filter: query['filter'] = request.filter
-        if max_results: query['max_results'] = request.max_results
-        if order_by: query['order_by'] = [v for v in request.order_by]
+        if events: query['events'] = [v for v in request.events]
+        if model_name: query['model_name'] = request.model_name
         if page_token: query['page_token'] = request.page_token
 
         while True:
-            json = self._api.do('GET', '/api/2.0/mlflow/registered-models/search', query=query)
-            if 'registered_models' not in json or not json['registered_models']:
+            json = self._api.do('GET', '/api/2.0/mlflow/registry-webhooks/list', query=query)
+            if 'webhooks' not in json or not json['webhooks']:
                 return
-            for v in json['registered_models']:
-                yield RegisteredModel.from_dict(v)
+            for v in json['webhooks']:
+                yield RegistryWebhook.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 set_tag(self, name: str, key: str, value: str, **kwargs):
-        """Set a tag.
-        
-        Sets a tag on a registered model."""
-        request = kwargs.get('request', None)
-        if not request: # request is not given through keyed args
-            request = SetRegisteredModelTagRequest(key=key, name=name, value=value)
-        body = request.as_dict()
-        self._api.do('POST', '/api/2.0/mlflow/registered-models/set-tag', body=body)
-
-    def update(self, name: str, *, description: str = None, **kwargs):
-        """Update model.
+    def reject_transition_request(self,
+                                  name: str,
+                                  version: str,
+                                  stage: Stage,
+                                  *,
+                                  comment: str = None,
+                                  **kwargs) -> RejectTransitionRequestResponse:
+        """Reject a transition request.
         
-        Updates a registered model."""
+        Rejects a model version stage transition request."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = UpdateRegisteredModelRequest(description=description, name=name)
+            request = RejectTransitionRequest(comment=comment, name=name, stage=stage, version=version)
         body = request.as_dict()
-        self._api.do('PATCH', '/api/2.0/mlflow/registered-models/update', body=body)
-
-
-class RegistryWebhooksAPI:
 
-    def __init__(self, api_client):
-        self._api = api_client
+        json = self._api.do('POST', '/api/2.0/mlflow/transition-requests/reject', body=body)
+        return RejectTransitionRequestResponse.from_dict(json)
 
-    def create(self,
-               events: List[RegistryWebhookEvent],
-               *,
-               description: str = None,
-               http_url_spec: HttpUrlSpec = None,
-               job_spec: JobSpec = None,
-               model_name: str = None,
-               status: RegistryWebhookStatus = None,
-               **kwargs) -> CreateResponse:
-        """Create a webhook.
-        
-        **NOTE**: This endpoint is in Public Preview.
+    def rename_model(self, name: str, *, new_name: str = None, **kwargs) -> RenameModelResponse:
+        """Rename a model.
         
-        Creates a registry webhook."""
+        Renames a registered model."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = CreateRegistryWebhook(description=description,
-                                            events=events,
-                                            http_url_spec=http_url_spec,
-                                            job_spec=job_spec,
-                                            model_name=model_name,
-                                            status=status)
+            request = RenameModelRequest(name=name, new_name=new_name)
         body = request.as_dict()
 
-        json = self._api.do('POST', '/api/2.0/mlflow/registry-webhooks/create', body=body)
-        return CreateResponse.from_dict(json)
-
-    def delete(self, *, id: str = None, **kwargs):
-        """Delete a webhook.
-        
-        **NOTE:** This endpoint is in Public Preview.
+        json = self._api.do('POST', '/api/2.0/mlflow/registered-models/rename', body=body)
+        return RenameModelResponse.from_dict(json)
+
+    def search_model_versions(self,
+                              *,
+                              filter: str = None,
+                              max_results: int = None,
+                              order_by: List[str] = None,
+                              page_token: str = None,
+                              **kwargs) -> Iterator[ModelVersion]:
+        """Searches model versions.
         
-        Deletes a registry webhook."""
+        Searches for specific model versions based on the supplied __filter__."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = DeleteRegistryWebhookRequest(id=id)
+            request = SearchModelVersionsRequest(filter=filter,
+                                                 max_results=max_results,
+                                                 order_by=order_by,
+                                                 page_token=page_token)
 
         query = {}
-        if id: query['id'] = request.id
+        if filter: query['filter'] = request.filter
+        if max_results: query['max_results'] = request.max_results
+        if order_by: query['order_by'] = [v for v in request.order_by]
+        if page_token: query['page_token'] = request.page_token
 
-        self._api.do('DELETE', '/api/2.0/mlflow/registry-webhooks/delete', query=query)
+        while True:
+            json = self._api.do('GET', '/api/2.0/mlflow/model-versions/search', query=query)
+            if 'model_versions' not in json or not json['model_versions']:
+                return
+            for v in json['model_versions']:
+                yield ModelVersion.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 list(self,
-             *,
-             events: List[RegistryWebhookEvent] = None,
-             model_name: str = None,
-             page_token: str = None,
-             **kwargs) -> Iterator[RegistryWebhook]:
-        """List registry webhooks.
-        
-        **NOTE:** This endpoint is in Public Preview.
+    def search_models(self,
+                      *,
+                      filter: str = None,
+                      max_results: int = None,
+                      order_by: List[str] = None,
+                      page_token: str = None,
+                      **kwargs) -> Iterator[Model]:
+        """Search models.
         
-        Lists all registry webhooks."""
+        Search for registered models based on the specified __filter__."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = ListRegistryWebhooksRequest(events=events, model_name=model_name, page_token=page_token)
+            request = SearchModelsRequest(filter=filter,
+                                          max_results=max_results,
+                                          order_by=order_by,
+                                          page_token=page_token)
 
         query = {}
-        if events: query['events'] = [v for v in request.events]
-        if model_name: query['model_name'] = request.model_name
+        if filter: query['filter'] = request.filter
+        if max_results: query['max_results'] = request.max_results
+        if order_by: query['order_by'] = [v for v in request.order_by]
         if page_token: query['page_token'] = request.page_token
 
         while True:
-            json = self._api.do('GET', '/api/2.0/mlflow/registry-webhooks/list', query=query)
-            if 'webhooks' not in json or not json['webhooks']:
+            json = self._api.do('GET', '/api/2.0/mlflow/registered-models/search', query=query)
+            if 'registered_models' not in json or not json['registered_models']:
                 return
-            for v in json['webhooks']:
-                yield RegistryWebhook.from_dict(v)
+            for v in json['registered_models']:
+                yield Model.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 test(self, id: str, *, event: RegistryWebhookEvent = None, **kwargs) -> TestRegistryWebhookResponse:
+    def set_model_tag(self, name: str, key: str, value: str, **kwargs):
+        """Set a tag.
+        
+        Sets a tag on a registered model."""
+        request = kwargs.get('request', None)
+        if not request: # request is not given through keyed args
+            request = SetModelTagRequest(key=key, name=name, value=value)
+        body = request.as_dict()
+        self._api.do('POST', '/api/2.0/mlflow/registered-models/set-tag', body=body)
+
+    def set_model_version_tag(self, name: str, version: str, key: str, value: str, **kwargs):
+        """Set a version tag.
+        
+        Sets a model version tag."""
+        request = kwargs.get('request', None)
+        if not request: # request is not given through keyed args
+            request = SetModelVersionTagRequest(key=key, name=name, value=value, version=version)
+        body = request.as_dict()
+        self._api.do('POST', '/api/2.0/mlflow/model-versions/set-tag', body=body)
+
+    def test_registry_webhook(self,
+                              id: str,
+                              *,
+                              event: RegistryWebhookEvent = None,
+                              **kwargs) -> TestRegistryWebhookResponse:
         """Test a webhook.
         
         **NOTE:** This endpoint is in Public Preview.
@@ -3111,128 +3058,86 @@ class RegistryWebhooksAPI:
         json = self._api.do('POST', '/api/2.0/mlflow/registry-webhooks/test', body=body)
         return TestRegistryWebhookResponse.from_dict(json)
 
-    def update(self,
-               id: str,
-               *,
-               description: str = None,
-               events: List[RegistryWebhookEvent] = None,
-               http_url_spec: HttpUrlSpec = None,
-               job_spec: JobSpec = None,
-               status: RegistryWebhookStatus = None,
-               **kwargs):
-        """Update a webhook.
+    def transition_stage(self,
+                         name: str,
+                         version: str,
+                         stage: Stage,
+                         archive_existing_versions: bool,
+                         *,
+                         comment: str = None,
+                         **kwargs) -> TransitionStageResponse:
+        """Transition a stage.
         
-        **NOTE:** This endpoint is in Public Preview.
+        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.",
         
-        Updates a registry webhook."""
+        [MLflow endpoint]: https://www.mlflow.org/docs/latest/rest-api.html#transition-modelversion-stage"""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = UpdateRegistryWebhook(description=description,
-                                            events=events,
-                                            http_url_spec=http_url_spec,
-                                            id=id,
-                                            job_spec=job_spec,
-                                            status=status)
+            request = TransitionModelVersionStageDatabricks(
+                archive_existing_versions=archive_existing_versions,
+                comment=comment,
+                name=name,
+                stage=stage,
+                version=version)
         body = request.as_dict()
-        self._api.do('PATCH', '/api/2.0/mlflow/registry-webhooks/update', body=body)
-
-
-class TransitionRequestsAPI:
 
-    def __init__(self, api_client):
-        self._api = api_client
+        json = self._api.do('POST', '/api/2.0/mlflow/databricks/model-versions/transition-stage', body=body)
+        return TransitionStageResponse.from_dict(json)
 
-    def approve(self,
-                name: str,
-                version: str,
-                stage: Stage,
-                archive_existing_versions: bool,
-                *,
-                comment: str = None,
-                **kwargs) -> ApproveResponse:
-        """Approve transition requests.
+    def update_comment(self, id: str, comment: str, **kwargs) -> UpdateCommentResponse:
+        """Update a comment.
         
-        Approves a model version stage transition request."""
+        Post an edit to a comment on a model version."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = ApproveTransitionRequest(archive_existing_versions=archive_existing_versions,
-                                               comment=comment,
-                                               name=name,
-                                               stage=stage,
-                                               version=version)
+            request = UpdateComment(comment=comment, id=id)
         body = request.as_dict()
 
-        json = self._api.do('POST', '/api/2.0/mlflow/transition-requests/approve', body=body)
-        return ApproveResponse.from_dict(json)
-
-    def create(self,
-               name: str,
-               version: str,
-               stage: Stage,
-               *,
-               comment: str = None,
-               **kwargs) -> CreateResponse:
-        """Make a transition request.
+        json = self._api.do('PATCH', '/api/2.0/mlflow/comments/update', body=body)
+        return UpdateCommentResponse.from_dict(json)
+
+    def update_model(self, name: str, *, description: str = None, **kwargs):
+        """Update model.
         
-        Creates a model version stage transition request."""
+        Updates a registered model."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = CreateTransitionRequest(comment=comment, name=name, stage=stage, version=version)
+            request = UpdateModelRequest(description=description, name=name)
         body = request.as_dict()
+        self._api.do('PATCH', '/api/2.0/mlflow/registered-models/update', body=body)
 
-        json = self._api.do('POST', '/api/2.0/mlflow/transition-requests/create', body=body)
-        return CreateResponse.from_dict(json)
-
-    def delete(self, name: str, version: str, stage: str, creator: str, *, comment: str = None, **kwargs):
-        """Delete a ransition request.
+    def update_model_version(self, name: str, version: str, *, description: str = None, **kwargs):
+        """Update model version.
         
-        Cancels a model version stage transition request."""
+        Updates the model version."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = DeleteTransitionRequestRequest(comment=comment,
-                                                     creator=creator,
-                                                     name=name,
-                                                     stage=stage,
-                                                     version=version)
-
-        query = {}
-        if comment: query['comment'] = request.comment
-        if creator: query['creator'] = request.creator
-        if name: query['name'] = request.name
-        if stage: query['stage'] = request.stage
-        if version: query['version'] = request.version
-
-        self._api.do('DELETE', '/api/2.0/mlflow/transition-requests/delete', query=query)
+            request = UpdateModelVersionRequest(description=description, name=name, version=version)
+        body = request.as_dict()
+        self._api.do('PATCH', '/api/2.0/mlflow/model-versions/update', body=body)
 
-    def list(self, name: str, version: str, **kwargs) -> Iterator[Activity]:
-        """List transition requests.
+    def update_webhook(self,
+                       id: str,
+                       *,
+                       description: str = None,
+                       events: List[RegistryWebhookEvent] = None,
+                       http_url_spec: HttpUrlSpec = None,
+                       job_spec: JobSpec = None,
+                       status: RegistryWebhookStatus = None,
+                       **kwargs):
+        """Update a webhook.
         
-        Gets a list of all open stage transition requests for the model version."""
-        request = kwargs.get('request', None)
-        if not request: # request is not given through keyed args
-            request = ListTransitionRequestsRequest(name=name, version=version)
-
-        query = {}
-        if name: query['name'] = request.name
-        if version: query['version'] = request.version
-
-        json = self._api.do('GET', '/api/2.0/mlflow/transition-requests/list', query=query)
-        return [Activity.from_dict(v) for v in json.get('requests', [])]
-
-    def reject(self,
-               name: str,
-               version: str,
-               stage: Stage,
-               *,
-               comment: str = None,
-               **kwargs) -> RejectResponse:
-        """Reject a transition request.
+        **NOTE:** This endpoint is in Public Preview.
         
-        Rejects a model version stage transition request."""
+        Updates a registry webhook."""
         request = kwargs.get('request', None)
         if not request: # request is not given through keyed args
-            request = RejectTransitionRequest(comment=comment, name=name, stage=stage, version=version)
+            request = UpdateRegistryWebhook(description=description,
+                                            events=events,
+                                            http_url_spec=http_url_spec,
+                                            id=id,
+                                            job_spec=job_spec,
+                                            status=status)
         body = request.as_dict()
-
-        json = self._api.do('POST', '/api/2.0/mlflow/transition-requests/reject', body=body)
-        return RejectResponse.from_dict(json)
+        self._api.do('PATCH', '/api/2.0/mlflow/registry-webhooks/update', body=body)