databricks-sdk 0.27.0__py3-none-any.whl → 0.28.0__py3-none-any.whl

databricks/sdk/service/catalog.py

@@ -1778,14 +1778,6 @@ class DisableResponse:
         return cls()
 
 
-class DisableSchemaName(Enum):
-
-    ACCESS = 'access'
-    BILLING = 'billing'
-    LINEAGE = 'lineage'
-    OPERATIONAL_DATA = 'operational_data'
-
-
 @dataclass
 class EffectivePermissionsList:
     privilege_assignments: Optional[List[EffectivePrivilegeAssignment]] = None
@@ -1916,14 +1908,6 @@ class EnableResponse:
         return cls()
 
 
-class EnableSchemaName(Enum):
-
-    ACCESS = 'access'
-    BILLING = 'billing'
-    LINEAGE = 'lineage'
-    OPERATIONAL_DATA = 'operational_data'
-
-
 @dataclass
 class EncryptionDetails:
     """Encryption options that apply to clients connecting to cloud storage."""
@@ -2575,16 +2559,22 @@ class ListConnectionsResponse:
     connections: Optional[List[ConnectionInfo]] = None
     """An array of connection information objects."""
 
+    next_page_token: Optional[str] = None
+    """Opaque token to retrieve the next page of results. Absent if there are no more pages.
+    __page_token__ should be set to this value for the next request (for the next page of results)."""
+
     def as_dict(self) -> dict:
         """Serializes the ListConnectionsResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.connections: body['connections'] = [v.as_dict() for v in self.connections]
+        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
         return body
 
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListConnectionsResponse:
         """Deserializes the ListConnectionsResponse from a dictionary."""
-        return cls(connections=_repeated_dict(d, 'connections', ConnectionInfo))
+        return cls(connections=_repeated_dict(d, 'connections', ConnectionInfo),
+                   next_page_token=d.get('next_page_token', None))
 
 
 @dataclass
@@ -3500,6 +3490,23 @@ class MonitorRefreshInfoTrigger(Enum):
     SCHEDULE = 'SCHEDULE'
 
 
+@dataclass
+class MonitorRefreshListResponse:
+    refreshes: Optional[List[MonitorRefreshInfo]] = None
+    """List of refreshes."""
+
+    def as_dict(self) -> dict:
+        """Serializes the MonitorRefreshListResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.refreshes: body['refreshes'] = [v.as_dict() for v in self.refreshes]
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> MonitorRefreshListResponse:
+        """Deserializes the MonitorRefreshListResponse from a dictionary."""
+        return cls(refreshes=_repeated_dict(d, 'refreshes', MonitorRefreshInfo))
+
+
 @dataclass
 class MonitorSnapshot:
 
@@ -3882,6 +3889,7 @@ class Privilege(Enum):
     REFRESH = 'REFRESH'
     SELECT = 'SELECT'
     SET_SHARE_PERMISSION = 'SET_SHARE_PERMISSION'
+    SINGLE_USER_ACCESS = 'SINGLE_USER_ACCESS'
     USAGE = 'USAGE'
     USE_CATALOG = 'USE_CATALOG'
     USE_CONNECTION = 'USE_CONNECTION'
@@ -5084,6 +5092,10 @@ class UpdateMonitor:
     metrics (from already computed aggregate metrics), or drift metrics (comparing metrics across
     time windows)."""
 
+    dashboard_id: Optional[str] = None
+    """Id of dashboard that visualizes the computed metrics. This can be empty if the monitor is in
+    PENDING state."""
+
     data_classification_config: Optional[MonitorDataClassificationConfig] = None
     """The data classification config for the monitor."""
 
@@ -5115,6 +5127,7 @@ class UpdateMonitor:
         body = {}
         if self.baseline_table_name is not None: body['baseline_table_name'] = self.baseline_table_name
         if self.custom_metrics: body['custom_metrics'] = [v.as_dict() for v in self.custom_metrics]
+        if self.dashboard_id is not None: body['dashboard_id'] = self.dashboard_id
         if self.data_classification_config:
             body['data_classification_config'] = self.data_classification_config.as_dict()
         if self.inference_log: body['inference_log'] = self.inference_log.as_dict()
@@ -5132,6 +5145,7 @@ class UpdateMonitor:
         """Deserializes the UpdateMonitor from a dictionary."""
         return cls(baseline_table_name=d.get('baseline_table_name', None),
                    custom_metrics=_repeated_dict(d, 'custom_metrics', MonitorMetric),
+                   dashboard_id=d.get('dashboard_id', None),
                    data_classification_config=_from_dict(d, 'data_classification_config',
                                                          MonitorDataClassificationConfig),
                    inference_log=_from_dict(d, 'inference_log', MonitorInferenceLog),
@@ -6372,19 +6386,38 @@ class ConnectionsAPI:
         res = self._api.do('GET', f'/api/2.1/unity-catalog/connections/{name}', headers=headers)
         return ConnectionInfo.from_dict(res)
 
-    def list(self) -> Iterator[ConnectionInfo]:
+    def list(self,
+             *,
+             max_results: Optional[int] = None,
+             page_token: Optional[str] = None) -> Iterator[ConnectionInfo]:
         """List connections.
         
         List all connections.
         
+        :param max_results: int (optional)
+          Maximum number of connections to return. - If not set, all connections are returned (not
+          recommended). - when set to a value greater than 0, the page length is the minimum of this value and
+          a server configured value; - when set to 0, the page length is set to a server configured value
+          (recommended); - when set to a value less than 0, an invalid parameter error is returned;
+        :param page_token: str (optional)
+          Opaque pagination token to go to next page based on previous query.
+        
         :returns: Iterator over :class:`ConnectionInfo`
         """
 
+        query = {}
+        if max_results is not None: query['max_results'] = max_results
+        if page_token is not None: query['page_token'] = page_token
         headers = {'Accept': 'application/json', }
 
-        json = self._api.do('GET', '/api/2.1/unity-catalog/connections', headers=headers)
-        parsed = ListConnectionsResponse.from_dict(json).connections
-        return parsed if parsed is not None else []
+        while True:
+            json = self._api.do('GET', '/api/2.1/unity-catalog/connections', query=query, headers=headers)
+            if 'connections' in json:
+                for v in json['connections']:
+                    yield ConnectionInfo.from_dict(v)
+            if 'next_page_token' not in json or not json['next_page_token']:
+                return
+            query['page_token'] = json['next_page_token']
 
     def update(self,
                name: str,
@@ -6896,364 +6929,249 @@ class GrantsAPI:
         return PermissionsList.from_dict(res)
 
 
-class LakehouseMonitorsAPI:
-    """A monitor computes and monitors data or model quality metrics for a table over time. It generates metrics
-    tables and a dashboard that you can use to monitor table health and set alerts.
+class MetastoresAPI:
+    """A metastore is the top-level container of objects in Unity Catalog. It stores data assets (tables and
+    views) and the permissions that govern access to them. Databricks account admins can create metastores and
+    assign them to Databricks workspaces to control which workloads use each metastore. For a workspace to use
+    Unity Catalog, it must have a Unity Catalog metastore attached.
     
-    Most write operations require the user to be the owner of the table (or its parent schema or parent
-    catalog). Viewing the dashboard, computed metrics, or monitor configuration only requires the user to have
-    **SELECT** privileges on the table (along with **USE_SCHEMA** and **USE_CATALOG**)."""
+    Each metastore is configured with a root storage location in a cloud storage account. This storage
+    location is used for metadata and managed tables data.
+    
+    NOTE: This metastore is distinct from the metastore included in Databricks workspaces created before Unity
+    Catalog was released. If your workspace includes a legacy Hive metastore, the data in that metastore is
+    available in a catalog named hive_metastore."""
 
     def __init__(self, api_client):
         self._api = api_client
 
-    def cancel_refresh(self, table_name: str, refresh_id: str):
-        """Cancel refresh.
-        
-        Cancel an active monitor refresh for the given refresh ID.
-        
-        The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
-        table's parent catalog and be an owner of the table's parent schema 3. have the following permissions:
-        - **USE_CATALOG** on the table's parent catalog - **USE_SCHEMA** on the table's parent schema - be an
-        owner of the table
+    def assign(self, workspace_id: int, metastore_id: str, default_catalog_name: str):
+        """Create an assignment.
         
-        Additionally, the call must be made from the workspace where the monitor was created.
+        Creates a new metastore assignment. If an assignment for the same __workspace_id__ exists, it will be
+        overwritten by the new __metastore_id__ and __default_catalog_name__. The caller must be an account
+        admin.
         
-        :param table_name: str
-          Full name of the table.
-        :param refresh_id: str
-          ID of the refresh.
+        :param workspace_id: int
+          A workspace ID.
+        :param metastore_id: str
+          The unique ID of the metastore.
+        :param default_catalog_name: str
+          The name of the default catalog in the metastore.
         
         
         """
+        body = {}
+        if default_catalog_name is not None: body['default_catalog_name'] = default_catalog_name
+        if metastore_id is not None: body['metastore_id'] = metastore_id
+        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
-        headers = {}
-
-        self._api.do('POST',
-                     f'/api/2.1/unity-catalog/tables/{table_name}/monitor/refreshes/{refresh_id}/cancel',
+        self._api.do('PUT',
+                     f'/api/2.1/unity-catalog/workspaces/{workspace_id}/metastore',
+                     body=body,
                      headers=headers)
 
     def create(self,
-               table_name: str,
-               assets_dir: str,
-               output_schema_name: str,
+               name: str,
                *,
-               baseline_table_name: Optional[str] = None,
-               custom_metrics: Optional[List[MonitorMetric]] = None,
-               data_classification_config: Optional[MonitorDataClassificationConfig] = None,
-               inference_log: Optional[MonitorInferenceLog] = None,
-               notifications: Optional[MonitorNotifications] = None,
-               schedule: Optional[MonitorCronSchedule] = None,
-               skip_builtin_dashboard: Optional[bool] = None,
-               slicing_exprs: Optional[List[str]] = None,
-               snapshot: Optional[MonitorSnapshot] = None,
-               time_series: Optional[MonitorTimeSeries] = None,
-               warehouse_id: Optional[str] = None) -> MonitorInfo:
-        """Create a table monitor.
-        
-        Creates a new monitor for the specified table.
-        
-        The caller must either: 1. be an owner of the table's parent catalog, have **USE_SCHEMA** on the
-        table's parent schema, and have **SELECT** access on the table 2. have **USE_CATALOG** on the table's
-        parent catalog, be an owner of the table's parent schema, and have **SELECT** access on the table. 3.
-        have the following permissions: - **USE_CATALOG** on the table's parent catalog - **USE_SCHEMA** on
-        the table's parent schema - be an owner of the table.
+               region: Optional[str] = None,
+               storage_root: Optional[str] = None) -> MetastoreInfo:
+        """Create a metastore.
         
-        Workspace assets, such as the dashboard, will be created in the workspace where this call was made.
+        Creates a new metastore based on a provided name and optional storage root path. By default (if the
+        __owner__ field is not set), the owner of the new metastore is the user calling the
+        __createMetastore__ API. If the __owner__ field is set to the empty string (**""**), the ownership is
+        assigned to the System User instead.
         
-        :param table_name: str
-          Full name of the table.
-        :param assets_dir: str
-          The directory to store monitoring assets (e.g. dashboard, metric tables).
-        :param output_schema_name: str
-          Schema where output metric tables are created.
-        :param baseline_table_name: str (optional)
-          Name of the baseline table from which drift metrics are computed from. Columns in the monitored
-          table should also be present in the baseline table.
-        :param custom_metrics: List[:class:`MonitorMetric`] (optional)
-          Custom metrics to compute on the monitored table. These can be aggregate metrics, derived metrics
-          (from already computed aggregate metrics), or drift metrics (comparing metrics across time windows).
-        :param data_classification_config: :class:`MonitorDataClassificationConfig` (optional)
-          The data classification config for the monitor.
-        :param inference_log: :class:`MonitorInferenceLog` (optional)
-          Configuration for monitoring inference logs.
-        :param notifications: :class:`MonitorNotifications` (optional)
-          The notification settings for the monitor.
-        :param schedule: :class:`MonitorCronSchedule` (optional)
-          The schedule for automatically updating and refreshing metric tables.
-        :param skip_builtin_dashboard: bool (optional)
-          Whether to skip creating a default dashboard summarizing data quality metrics.
-        :param slicing_exprs: List[str] (optional)
-          List of column expressions to slice data with for targeted analysis. The data is grouped by each
-          expression independently, resulting in a separate slice for each predicate and its complements. For
-          high-cardinality columns, only the top 100 unique values by frequency will generate slices.
-        :param snapshot: :class:`MonitorSnapshot` (optional)
-          Configuration for monitoring snapshot tables.
-        :param time_series: :class:`MonitorTimeSeries` (optional)
-          Configuration for monitoring time series tables.
-        :param warehouse_id: str (optional)
-          Optional argument to specify the warehouse for dashboard creation. If not specified, the first
-          running warehouse will be used.
+        :param name: str
+          The user-specified name of the metastore.
+        :param region: str (optional)
+          Cloud region which the metastore serves (e.g., `us-west-2`, `westus`). If this field is omitted, the
+          region of the workspace receiving the request will be used.
+        :param storage_root: str (optional)
+          The storage root URL for metastore
         
-        :returns: :class:`MonitorInfo`
+        :returns: :class:`MetastoreInfo`
         """
         body = {}
-        if assets_dir is not None: body['assets_dir'] = assets_dir
-        if baseline_table_name is not None: body['baseline_table_name'] = baseline_table_name
-        if custom_metrics is not None: body['custom_metrics'] = [v.as_dict() for v in custom_metrics]
-        if data_classification_config is not None:
-            body['data_classification_config'] = data_classification_config.as_dict()
-        if inference_log is not None: body['inference_log'] = inference_log.as_dict()
-        if notifications is not None: body['notifications'] = notifications.as_dict()
-        if output_schema_name is not None: body['output_schema_name'] = output_schema_name
-        if schedule is not None: body['schedule'] = schedule.as_dict()
-        if skip_builtin_dashboard is not None: body['skip_builtin_dashboard'] = skip_builtin_dashboard
-        if slicing_exprs is not None: body['slicing_exprs'] = [v for v in slicing_exprs]
-        if snapshot is not None: body['snapshot'] = snapshot.as_dict()
-        if time_series is not None: body['time_series'] = time_series.as_dict()
-        if warehouse_id is not None: body['warehouse_id'] = warehouse_id
+        if name is not None: body['name'] = name
+        if region is not None: body['region'] = region
+        if storage_root is not None: body['storage_root'] = storage_root
         headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
-        res = self._api.do('POST',
-                           f'/api/2.1/unity-catalog/tables/{table_name}/monitor',
-                           body=body,
-                           headers=headers)
-        return MonitorInfo.from_dict(res)
+        res = self._api.do('POST', '/api/2.1/unity-catalog/metastores', body=body, headers=headers)
+        return MetastoreInfo.from_dict(res)
 
-    def delete(self, table_name: str):
-        """Delete a table monitor.
-        
-        Deletes a monitor for the specified table.
+    def current(self) -> MetastoreAssignment:
+        """Get metastore assignment for workspace.
         
-        The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
-        table's parent catalog and be an owner of the table's parent schema 3. have the following permissions:
-        - **USE_CATALOG** on the table's parent catalog - **USE_SCHEMA** on the table's parent schema - be an
-        owner of the table.
+        Gets the metastore assignment for the workspace being accessed.
         
-        Additionally, the call must be made from the workspace where the monitor was created.
+        :returns: :class:`MetastoreAssignment`
+        """
+
+        headers = {'Accept': 'application/json', }
+
+        res = self._api.do('GET', '/api/2.1/unity-catalog/current-metastore-assignment', headers=headers)
+        return MetastoreAssignment.from_dict(res)
+
+    def delete(self, id: str, *, force: Optional[bool] = None):
+        """Delete a metastore.
         
-        Note that the metric tables and dashboard will not be deleted as part of this call; those assets must
-        be manually cleaned up (if desired).
+        Deletes a metastore. The caller must be a metastore admin.
         
-        :param table_name: str
-          Full name of the table.
+        :param id: str
+          Unique ID of the metastore.
+        :param force: bool (optional)
+          Force deletion even if the metastore is not empty. Default is false.
         
         
         """
 
-        headers = {}
+        query = {}
+        if force is not None: query['force'] = force
+        headers = {'Accept': 'application/json', }
 
-        self._api.do('DELETE', f'/api/2.1/unity-catalog/tables/{table_name}/monitor', headers=headers)
+        self._api.do('DELETE', f'/api/2.1/unity-catalog/metastores/{id}', query=query, headers=headers)
 
-    def get(self, table_name: str) -> MonitorInfo:
-        """Get a table monitor.
-        
-        Gets a monitor for the specified table.
-        
-        The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
-        table's parent catalog and be an owner of the table's parent schema. 3. have the following
-        permissions: - **USE_CATALOG** on the table's parent catalog - **USE_SCHEMA** on the table's parent
-        schema - **SELECT** privilege on the table.
+    def get(self, id: str) -> MetastoreInfo:
+        """Get a metastore.
         
-        The returned information includes configuration values, as well as information on assets created by
-        the monitor. Some information (e.g., dashboard) may be filtered out if the caller is in a different
-        workspace than where the monitor was created.
+        Gets a metastore that matches the supplied ID. The caller must be a metastore admin to retrieve this
+        info.
         
-        :param table_name: str
-          Full name of the table.
+        :param id: str
+          Unique ID of the metastore.
         
-        :returns: :class:`MonitorInfo`
+        :returns: :class:`MetastoreInfo`
         """
 
         headers = {'Accept': 'application/json', }
 
-        res = self._api.do('GET', f'/api/2.1/unity-catalog/tables/{table_name}/monitor', headers=headers)
-        return MonitorInfo.from_dict(res)
+        res = self._api.do('GET', f'/api/2.1/unity-catalog/metastores/{id}', headers=headers)
+        return MetastoreInfo.from_dict(res)
 
-    def get_refresh(self, table_name: str, refresh_id: str) -> MonitorRefreshInfo:
-        """Get refresh.
-        
-        Gets info about a specific monitor refresh using the given refresh ID.
-        
-        The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
-        table's parent catalog and be an owner of the table's parent schema 3. have the following permissions:
-        - **USE_CATALOG** on the table's parent catalog - **USE_SCHEMA** on the table's parent schema -
-        **SELECT** privilege on the table.
-        
-        Additionally, the call must be made from the workspace where the monitor was created.
+    def list(self) -> Iterator[MetastoreInfo]:
+        """List metastores.
         
-        :param table_name: str
-          Full name of the table.
-        :param refresh_id: str
-          ID of the refresh.
+        Gets an array of the available metastores (as __MetastoreInfo__ objects). The caller must be an admin
+        to retrieve this info. There is no guarantee of a specific ordering of the elements in the array.
         
-        :returns: :class:`MonitorRefreshInfo`
+        :returns: Iterator over :class:`MetastoreInfo`
         """
 
         headers = {'Accept': 'application/json', }
 
-        res = self._api.do('GET',
-                           f'/api/2.1/unity-catalog/tables/{table_name}/monitor/refreshes/{refresh_id}',
-                           headers=headers)
-        return MonitorRefreshInfo.from_dict(res)
+        json = self._api.do('GET', '/api/2.1/unity-catalog/metastores', headers=headers)
+        parsed = ListMetastoresResponse.from_dict(json).metastores
+        return parsed if parsed is not None else []
 
-    def list_refreshes(self, table_name: str) -> Iterator[MonitorRefreshInfo]:
-        """List refreshes.
-        
-        Gets an array containing the history of the most recent refreshes (up to 25) for this table.
-        
-        The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
-        table's parent catalog and be an owner of the table's parent schema 3. have the following permissions:
-        - **USE_CATALOG** on the table's parent catalog - **USE_SCHEMA** on the table's parent schema -
-        **SELECT** privilege on the table.
-        
-        Additionally, the call must be made from the workspace where the monitor was created.
+    def summary(self) -> GetMetastoreSummaryResponse:
+        """Get a metastore summary.
         
-        :param table_name: str
-          Full name of the table.
+        Gets information about a metastore. This summary includes the storage credential, the cloud vendor,
+        the cloud region, and the global metastore ID.
         
-        :returns: Iterator over :class:`MonitorRefreshInfo`
+        :returns: :class:`GetMetastoreSummaryResponse`
         """
 
         headers = {'Accept': 'application/json', }
 
-        res = self._api.do('GET',
-                           f'/api/2.1/unity-catalog/tables/{table_name}/monitor/refreshes',
-                           headers=headers)
-        return [MonitorRefreshInfo.from_dict(v) for v in res]
+        res = self._api.do('GET', '/api/2.1/unity-catalog/metastore_summary', headers=headers)
+        return GetMetastoreSummaryResponse.from_dict(res)
 
-    def run_refresh(self, table_name: str) -> MonitorRefreshInfo:
-        """Queue a metric refresh for a monitor.
-        
-        Queues a metric refresh on the monitor for the specified table. The refresh will execute in the
-        background.
+    def unassign(self, workspace_id: int, metastore_id: str):
+        """Delete an assignment.
         
-        The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
-        table's parent catalog and be an owner of the table's parent schema 3. have the following permissions:
-        - **USE_CATALOG** on the table's parent catalog - **USE_SCHEMA** on the table's parent schema - be an
-        owner of the table
+        Deletes a metastore assignment. The caller must be an account administrator.
         
-        Additionally, the call must be made from the workspace where the monitor was created.
+        :param workspace_id: int
+          A workspace ID.
+        :param metastore_id: str
+          Query for the ID of the metastore to delete.
         
-        :param table_name: str
-          Full name of the table.
         
-        :returns: :class:`MonitorRefreshInfo`
         """
 
+        query = {}
+        if metastore_id is not None: query['metastore_id'] = metastore_id
         headers = {'Accept': 'application/json', }
 
-        res = self._api.do('POST',
-                           f'/api/2.1/unity-catalog/tables/{table_name}/monitor/refreshes',
-                           headers=headers)
-        return MonitorRefreshInfo.from_dict(res)
+        self._api.do('DELETE',
+                     f'/api/2.1/unity-catalog/workspaces/{workspace_id}/metastore',
+                     query=query,
+                     headers=headers)
 
     def update(self,
-               table_name: str,
-               output_schema_name: str,
+               id: str,
                *,
-               baseline_table_name: Optional[str] = None,
-               custom_metrics: Optional[List[MonitorMetric]] = None,
-               data_classification_config: Optional[MonitorDataClassificationConfig] = None,
-               inference_log: Optional[MonitorInferenceLog] = None,
-               notifications: Optional[MonitorNotifications] = None,
-               schedule: Optional[MonitorCronSchedule] = None,
-               slicing_exprs: Optional[List[str]] = None,
-               snapshot: Optional[MonitorSnapshot] = None,
-               time_series: Optional[MonitorTimeSeries] = None) -> MonitorInfo:
-        """Update a table monitor.
-        
-        Updates a monitor for the specified table.
-        
-        The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
-        table's parent catalog and be an owner of the table's parent schema 3. have the following permissions:
-        - **USE_CATALOG** on the table's parent catalog - **USE_SCHEMA** on the table's parent schema - be an
-        owner of the table.
-        
-        Additionally, the call must be made from the workspace where the monitor was created, and the caller
-        must be the original creator of the monitor.
+               delta_sharing_organization_name: Optional[str] = None,
+               delta_sharing_recipient_token_lifetime_in_seconds: Optional[int] = None,
+               delta_sharing_scope: Optional[UpdateMetastoreDeltaSharingScope] = None,
+               new_name: Optional[str] = None,
+               owner: Optional[str] = None,
+               privilege_model_version: Optional[str] = None,
+               storage_root_credential_id: Optional[str] = None) -> MetastoreInfo:
+        """Update a metastore.
         
-        Certain configuration fields, such as output asset identifiers, cannot be updated.
+        Updates information for a specific metastore. The caller must be a metastore admin. If the __owner__
+        field is set to the empty string (**""**), the ownership is updated to the System User.
         
-        :param table_name: str
-          Full name of the table.
-        :param output_schema_name: str
-          Schema where output metric tables are created.
-        :param baseline_table_name: str (optional)
-          Name of the baseline table from which drift metrics are computed from. Columns in the monitored
-          table should also be present in the baseline table.
-        :param custom_metrics: List[:class:`MonitorMetric`] (optional)
-          Custom metrics to compute on the monitored table. These can be aggregate metrics, derived metrics
-          (from already computed aggregate metrics), or drift metrics (comparing metrics across time windows).
-        :param data_classification_config: :class:`MonitorDataClassificationConfig` (optional)
-          The data classification config for the monitor.
-        :param inference_log: :class:`MonitorInferenceLog` (optional)
-          Configuration for monitoring inference logs.
-        :param notifications: :class:`MonitorNotifications` (optional)
-          The notification settings for the monitor.
-        :param schedule: :class:`MonitorCronSchedule` (optional)
-          The schedule for automatically updating and refreshing metric tables.
-        :param slicing_exprs: List[str] (optional)
-          List of column expressions to slice data with for targeted analysis. The data is grouped by each
-          expression independently, resulting in a separate slice for each predicate and its complements. For
-          high-cardinality columns, only the top 100 unique values by frequency will generate slices.
-        :param snapshot: :class:`MonitorSnapshot` (optional)
-          Configuration for monitoring snapshot tables.
-        :param time_series: :class:`MonitorTimeSeries` (optional)
-          Configuration for monitoring time series tables.
+        :param id: str
+          Unique ID of the metastore.
+        :param delta_sharing_organization_name: str (optional)
+          The organization name of a Delta Sharing entity, to be used in Databricks-to-Databricks Delta
+          Sharing as the official name.
+        :param delta_sharing_recipient_token_lifetime_in_seconds: int (optional)
+          The lifetime of delta sharing recipient token in seconds.
+        :param delta_sharing_scope: :class:`UpdateMetastoreDeltaSharingScope` (optional)
+          The scope of Delta Sharing enabled for the metastore.
+        :param new_name: str (optional)
+          New name for the metastore.
+        :param owner: str (optional)
+          The owner of the metastore.
+        :param privilege_model_version: str (optional)
+          Privilege model version of the metastore, of the form `major.minor` (e.g., `1.0`).
+        :param storage_root_credential_id: str (optional)
+          UUID of storage credential to access the metastore storage_root.
         
-        :returns: :class:`MonitorInfo`
+        :returns: :class:`MetastoreInfo`
         """
         body = {}
-        if baseline_table_name is not None: body['baseline_table_name'] = baseline_table_name
-        if custom_metrics is not None: body['custom_metrics'] = [v.as_dict() for v in custom_metrics]
-        if data_classification_config is not None:
-            body['data_classification_config'] = data_classification_config.as_dict()
-        if inference_log is not None: body['inference_log'] = inference_log.as_dict()
-        if notifications is not None: body['notifications'] = notifications.as_dict()
-        if output_schema_name is not None: body['output_schema_name'] = output_schema_name
-        if schedule is not None: body['schedule'] = schedule.as_dict()
-        if slicing_exprs is not None: body['slicing_exprs'] = [v for v in slicing_exprs]
-        if snapshot is not None: body['snapshot'] = snapshot.as_dict()
-        if time_series is not None: body['time_series'] = time_series.as_dict()
+        if delta_sharing_organization_name is not None:
+            body['delta_sharing_organization_name'] = delta_sharing_organization_name
+        if delta_sharing_recipient_token_lifetime_in_seconds is not None:
+            body[
+                'delta_sharing_recipient_token_lifetime_in_seconds'] = delta_sharing_recipient_token_lifetime_in_seconds
+        if delta_sharing_scope is not None: body['delta_sharing_scope'] = delta_sharing_scope.value
+        if new_name is not None: body['new_name'] = new_name
+        if owner is not None: body['owner'] = owner
+        if privilege_model_version is not None: body['privilege_model_version'] = privilege_model_version
+        if storage_root_credential_id is not None:
+            body['storage_root_credential_id'] = storage_root_credential_id
         headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
-        res = self._api.do('PUT',
-                           f'/api/2.1/unity-catalog/tables/{table_name}/monitor',
-                           body=body,
-                           headers=headers)
-        return MonitorInfo.from_dict(res)
-
-
-class MetastoresAPI:
-    """A metastore is the top-level container of objects in Unity Catalog. It stores data assets (tables and
-    views) and the permissions that govern access to them. Databricks account admins can create metastores and
-    assign them to Databricks workspaces to control which workloads use each metastore. For a workspace to use
-    Unity Catalog, it must have a Unity Catalog metastore attached.
-    
-    Each metastore is configured with a root storage location in a cloud storage account. This storage
-    location is used for metadata and managed tables data.
-    
-    NOTE: This metastore is distinct from the metastore included in Databricks workspaces created before Unity
-    Catalog was released. If your workspace includes a legacy Hive metastore, the data in that metastore is
-    available in a catalog named hive_metastore."""
-
-    def __init__(self, api_client):
-        self._api = api_client
+        res = self._api.do('PATCH', f'/api/2.1/unity-catalog/metastores/{id}', body=body, headers=headers)
+        return MetastoreInfo.from_dict(res)
 
-    def assign(self, workspace_id: int, metastore_id: str, default_catalog_name: str):
-        """Create an assignment.
+    def update_assignment(self,
+                          workspace_id: int,
+                          *,
+                          default_catalog_name: Optional[str] = None,
+                          metastore_id: Optional[str] = None):
+        """Update an assignment.
         
-        Creates a new metastore assignment. If an assignment for the same __workspace_id__ exists, it will be
-        overwritten by the new __metastore_id__ and __default_catalog_name__. The caller must be an account
-        admin.
+        Updates a metastore assignment. This operation can be used to update __metastore_id__ or
+        __default_catalog_name__ for a specified Workspace, if the Workspace is already assigned a metastore.
+        The caller must be an account admin to update __metastore_id__; otherwise, the caller can be a
+        Workspace admin.
         
         :param workspace_id: int
           A workspace ID.
-        :param metastore_id: str
+        :param default_catalog_name: str (optional)
+          The name of the default catalog for the metastore.
+        :param metastore_id: str (optional)
           The unique ID of the metastore.
-        :param default_catalog_name: str
-          The name of the default catalog in the metastore.
         
         
         """
@@ -7262,463 +7180,583 @@ class MetastoresAPI:
         if metastore_id is not None: body['metastore_id'] = metastore_id
         headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
-        self._api.do('PUT',
+        self._api.do('PATCH',
                      f'/api/2.1/unity-catalog/workspaces/{workspace_id}/metastore',
                      body=body,
                      headers=headers)
 
-    def create(self,
-               name: str,
-               *,
-               region: Optional[str] = None,
-               storage_root: Optional[str] = None) -> MetastoreInfo:
-        """Create a metastore.
+
+class ModelVersionsAPI:
+    """Databricks provides a hosted version of MLflow Model Registry in Unity Catalog. Models in Unity Catalog
+    provide centralized access control, auditing, lineage, and discovery of ML models across Databricks
+    workspaces.
+    
+    This API reference documents the REST endpoints for managing model versions in Unity Catalog. For more
+    details, see the [registered models API docs](/api/workspace/registeredmodels)."""
+
+    def __init__(self, api_client):
+        self._api = api_client
+
+    def delete(self, full_name: str, version: int):
+        """Delete a Model Version.
         
-        Creates a new metastore based on a provided name and optional storage root path. By default (if the
-        __owner__ field is not set), the owner of the new metastore is the user calling the
-        __createMetastore__ API. If the __owner__ field is set to the empty string (**""**), the ownership is
-        assigned to the System User instead.
+        Deletes a model version from the specified registered model. Any aliases assigned to the model version
+        will also be deleted.
         
-        :param name: str
-          The user-specified name of the metastore.
-        :param region: str (optional)
-          Cloud region which the metastore serves (e.g., `us-west-2`, `westus`). If this field is omitted, the
-          region of the workspace receiving the request will be used.
-        :param storage_root: str (optional)
-          The storage root URL for metastore
+        The caller must be a metastore admin or an owner of the parent registered model. For the latter case,
+        the caller must also be the owner or have the **USE_CATALOG** privilege on the parent catalog and the
+        **USE_SCHEMA** privilege on the parent schema.
         
-        :returns: :class:`MetastoreInfo`
-        """
-        body = {}
-        if name is not None: body['name'] = name
-        if region is not None: body['region'] = region
-        if storage_root is not None: body['storage_root'] = storage_root
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
-
-        res = self._api.do('POST', '/api/2.1/unity-catalog/metastores', body=body, headers=headers)
-        return MetastoreInfo.from_dict(res)
-
-    def current(self) -> MetastoreAssignment:
-        """Get metastore assignment for workspace.
+        :param full_name: str
+          The three-level (fully qualified) name of the model version
+        :param version: int
+          The integer version number of the model version
         
-        Gets the metastore assignment for the workspace being accessed.
         
-        :returns: :class:`MetastoreAssignment`
         """
 
-        headers = {'Accept': 'application/json', }
+        headers = {}
 
-        res = self._api.do('GET', '/api/2.1/unity-catalog/current-metastore-assignment', headers=headers)
-        return MetastoreAssignment.from_dict(res)
+        self._api.do('DELETE',
+                     f'/api/2.1/unity-catalog/models/{full_name}/versions/{version}',
+                     headers=headers)
 
-    def delete(self, id: str, *, force: Optional[bool] = None):
-        """Delete a metastore.
+    def get(self,
+            full_name: str,
+            version: int,
+            *,
+            include_browse: Optional[bool] = None) -> RegisteredModelInfo:
+        """Get a Model Version.
         
-        Deletes a metastore. The caller must be a metastore admin.
+        Get a model version.
         
-        :param id: str
-          Unique ID of the metastore.
-        :param force: bool (optional)
-          Force deletion even if the metastore is not empty. Default is false.
+        The caller must be a metastore admin or an owner of (or have the **EXECUTE** privilege on) the parent
+        registered model. For the latter case, the caller must also be the owner or have the **USE_CATALOG**
+        privilege on the parent catalog and the **USE_SCHEMA** privilege on the parent schema.
         
+        :param full_name: str
+          The three-level (fully qualified) name of the model version
+        :param version: int
+          The integer version number of the model version
+        :param include_browse: bool (optional)
+          Whether to include model versions in the response for which the principal can only access selective
+          metadata for
         
+        :returns: :class:`RegisteredModelInfo`
         """
 
         query = {}
-        if force is not None: query['force'] = force
+        if include_browse is not None: query['include_browse'] = include_browse
         headers = {'Accept': 'application/json', }
 
-        self._api.do('DELETE', f'/api/2.1/unity-catalog/metastores/{id}', query=query, headers=headers)
+        res = self._api.do('GET',
+                           f'/api/2.1/unity-catalog/models/{full_name}/versions/{version}',
+                           query=query,
+                           headers=headers)
+        return RegisteredModelInfo.from_dict(res)
 
-    def get(self, id: str) -> MetastoreInfo:
-        """Get a metastore.
+    def get_by_alias(self, full_name: str, alias: str) -> ModelVersionInfo:
+        """Get Model Version By Alias.
         
-        Gets a metastore that matches the supplied ID. The caller must be a metastore admin to retrieve this
-        info.
+        Get a model version by alias.
         
-        :param id: str
-          Unique ID of the metastore.
+        The caller must be a metastore admin or an owner of (or have the **EXECUTE** privilege on) the
+        registered model. For the latter case, the caller must also be the owner or have the **USE_CATALOG**
+        privilege on the parent catalog and the **USE_SCHEMA** privilege on the parent schema.
         
-        :returns: :class:`MetastoreInfo`
+        :param full_name: str
+          The three-level (fully qualified) name of the registered model
+        :param alias: str
+          The name of the alias
+        
+        :returns: :class:`ModelVersionInfo`
         """
 
         headers = {'Accept': 'application/json', }
 
-        res = self._api.do('GET', f'/api/2.1/unity-catalog/metastores/{id}', headers=headers)
-        return MetastoreInfo.from_dict(res)
+        res = self._api.do('GET',
+                           f'/api/2.1/unity-catalog/models/{full_name}/aliases/{alias}',
+                           headers=headers)
+        return ModelVersionInfo.from_dict(res)
 
-    def list(self) -> Iterator[MetastoreInfo]:
-        """List metastores.
+    def list(self,
+             full_name: str,
+             *,
+             include_browse: Optional[bool] = None,
+             max_results: Optional[int] = None,
+             page_token: Optional[str] = None) -> Iterator[ModelVersionInfo]:
+        """List Model Versions.
         
-        Gets an array of the available metastores (as __MetastoreInfo__ objects). The caller must be an admin
-        to retrieve this info. There is no guarantee of a specific ordering of the elements in the array.
+        List model versions. You can list model versions under a particular schema, or list all model versions
+        in the current metastore.
         
-        :returns: Iterator over :class:`MetastoreInfo`
-        """
-
-        headers = {'Accept': 'application/json', }
-
-        json = self._api.do('GET', '/api/2.1/unity-catalog/metastores', headers=headers)
-        parsed = ListMetastoresResponse.from_dict(json).metastores
-        return parsed if parsed is not None else []
-
-    def summary(self) -> GetMetastoreSummaryResponse:
-        """Get a metastore summary.
+        The returned models are filtered based on the privileges of the calling user. For example, the
+        metastore admin is able to list all the model versions. A regular user needs to be the owner or have
+        the **EXECUTE** privilege on the parent registered model to recieve the model versions in the
+        response. For the latter case, the caller must also be the owner or have the **USE_CATALOG** privilege
+        on the parent catalog and the **USE_SCHEMA** privilege on the parent schema.
         
-        Gets information about a metastore. This summary includes the storage credential, the cloud vendor,
-        the cloud region, and the global metastore ID.
+        There is no guarantee of a specific ordering of the elements in the response. The elements in the
+        response will not contain any aliases or tags.
         
-        :returns: :class:`GetMetastoreSummaryResponse`
+        :param full_name: str
+          The full three-level name of the registered model under which to list model versions
+        :param include_browse: bool (optional)
+          Whether to include model versions in the response for which the principal can only access selective
+          metadata for
+        :param max_results: int (optional)
+          Maximum number of model versions to return. If not set, the page length is set to a server
+          configured value (100, as of 1/3/2024). - when set to a value greater than 0, the page length is the
+          minimum of this value and a server configured value(1000, as of 1/3/2024); - when set to 0, the page
+          length is set to a server configured value (100, as of 1/3/2024) (recommended); - when set to a
+          value less than 0, an invalid parameter error is returned;
+        :param page_token: str (optional)
+          Opaque pagination token to go to next page based on previous query.
+        
+        :returns: Iterator over :class:`ModelVersionInfo`
         """
 
+        query = {}
+        if include_browse is not None: query['include_browse'] = include_browse
+        if max_results is not None: query['max_results'] = max_results
+        if page_token is not None: query['page_token'] = page_token
         headers = {'Accept': 'application/json', }
 
-        res = self._api.do('GET', '/api/2.1/unity-catalog/metastore_summary', headers=headers)
-        return GetMetastoreSummaryResponse.from_dict(res)
+        while True:
+            json = self._api.do('GET',
+                                f'/api/2.1/unity-catalog/models/{full_name}/versions',
+                                query=query,
+                                headers=headers)
+            if 'model_versions' in json:
+                for v in json['model_versions']:
+                    yield ModelVersionInfo.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 unassign(self, workspace_id: int, metastore_id: str):
-        """Delete an assignment.
+    def update(self, full_name: str, version: int, *, comment: Optional[str] = None) -> ModelVersionInfo:
+        """Update a Model Version.
         
-        Deletes a metastore assignment. The caller must be an account administrator.
+        Updates the specified model version.
         
-        :param workspace_id: int
-          A workspace ID.
-        :param metastore_id: str
-          Query for the ID of the metastore to delete.
+        The caller must be a metastore admin or an owner of the parent registered model. For the latter case,
+        the caller must also be the owner or have the **USE_CATALOG** privilege on the parent catalog and the
+        **USE_SCHEMA** privilege on the parent schema.
+        
+        Currently only the comment of the model version can be updated.
         
+        :param full_name: str
+          The three-level (fully qualified) name of the model version
+        :param version: int
+          The integer version number of the model version
+        :param comment: str (optional)
+          The comment attached to the model version
         
+        :returns: :class:`ModelVersionInfo`
         """
+        body = {}
+        if comment is not None: body['comment'] = comment
+        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
-        query = {}
-        if metastore_id is not None: query['metastore_id'] = metastore_id
-        headers = {'Accept': 'application/json', }
+        res = self._api.do('PATCH',
+                           f'/api/2.1/unity-catalog/models/{full_name}/versions/{version}',
+                           body=body,
+                           headers=headers)
+        return ModelVersionInfo.from_dict(res)
 
-        self._api.do('DELETE',
-                     f'/api/2.1/unity-catalog/workspaces/{workspace_id}/metastore',
-                     query=query,
-                     headers=headers)
 
-    def update(self,
-               id: str,
-               *,
-               delta_sharing_organization_name: Optional[str] = None,
-               delta_sharing_recipient_token_lifetime_in_seconds: Optional[int] = None,
-               delta_sharing_scope: Optional[UpdateMetastoreDeltaSharingScope] = None,
-               new_name: Optional[str] = None,
-               owner: Optional[str] = None,
-               privilege_model_version: Optional[str] = None,
-               storage_root_credential_id: Optional[str] = None) -> MetastoreInfo:
-        """Update a metastore.
+class OnlineTablesAPI:
+    """Online tables provide lower latency and higher QPS access to data from Delta tables."""
+
+    def __init__(self, api_client):
+        self._api = api_client
+
+    def create(self, *, name: Optional[str] = None, spec: Optional[OnlineTableSpec] = None) -> OnlineTable:
+        """Create an Online Table.
         
-        Updates information for a specific metastore. The caller must be a metastore admin. If the __owner__
-        field is set to the empty string (**""**), the ownership is updated to the System User.
+        Create a new Online Table.
         
-        :param id: str
-          Unique ID of the metastore.
-        :param delta_sharing_organization_name: str (optional)
-          The organization name of a Delta Sharing entity, to be used in Databricks-to-Databricks Delta
-          Sharing as the official name.
-        :param delta_sharing_recipient_token_lifetime_in_seconds: int (optional)
-          The lifetime of delta sharing recipient token in seconds.
-        :param delta_sharing_scope: :class:`UpdateMetastoreDeltaSharingScope` (optional)
-          The scope of Delta Sharing enabled for the metastore.
-        :param new_name: str (optional)
-          New name for the metastore.
-        :param owner: str (optional)
-          The owner of the metastore.
-        :param privilege_model_version: str (optional)
-          Privilege model version of the metastore, of the form `major.minor` (e.g., `1.0`).
-        :param storage_root_credential_id: str (optional)
-          UUID of storage credential to access the metastore storage_root.
+        :param name: str (optional)
+          Full three-part (catalog, schema, table) name of the table.
+        :param spec: :class:`OnlineTableSpec` (optional)
+          Specification of the online table.
         
-        :returns: :class:`MetastoreInfo`
+        :returns: :class:`OnlineTable`
         """
         body = {}
-        if delta_sharing_organization_name is not None:
-            body['delta_sharing_organization_name'] = delta_sharing_organization_name
-        if delta_sharing_recipient_token_lifetime_in_seconds is not None:
-            body[
-                'delta_sharing_recipient_token_lifetime_in_seconds'] = delta_sharing_recipient_token_lifetime_in_seconds
-        if delta_sharing_scope is not None: body['delta_sharing_scope'] = delta_sharing_scope.value
-        if new_name is not None: body['new_name'] = new_name
-        if owner is not None: body['owner'] = owner
-        if privilege_model_version is not None: body['privilege_model_version'] = privilege_model_version
-        if storage_root_credential_id is not None:
-            body['storage_root_credential_id'] = storage_root_credential_id
+        if name is not None: body['name'] = name
+        if spec is not None: body['spec'] = spec.as_dict()
         headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
-        res = self._api.do('PATCH', f'/api/2.1/unity-catalog/metastores/{id}', body=body, headers=headers)
-        return MetastoreInfo.from_dict(res)
+        res = self._api.do('POST', '/api/2.0/online-tables', body=body, headers=headers)
+        return OnlineTable.from_dict(res)
 
-    def update_assignment(self,
-                          workspace_id: int,
-                          *,
-                          default_catalog_name: Optional[str] = None,
-                          metastore_id: Optional[str] = None):
-        """Update an assignment.
+    def delete(self, name: str):
+        """Delete an Online Table.
         
-        Updates a metastore assignment. This operation can be used to update __metastore_id__ or
-        __default_catalog_name__ for a specified Workspace, if the Workspace is already assigned a metastore.
-        The caller must be an account admin to update __metastore_id__; otherwise, the caller can be a
-        Workspace admin.
+        Delete an online table. Warning: This will delete all the data in the online table. If the source
+        Delta table was deleted or modified since this Online Table was created, this will lose the data
+        forever!
         
-        :param workspace_id: int
-          A workspace ID.
-        :param default_catalog_name: str (optional)
-          The name of the default catalog for the metastore.
-        :param metastore_id: str (optional)
-          The unique ID of the metastore.
+        :param name: str
+          Full three-part (catalog, schema, table) name of the table.
         
         
         """
-        body = {}
-        if default_catalog_name is not None: body['default_catalog_name'] = default_catalog_name
-        if metastore_id is not None: body['metastore_id'] = metastore_id
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
-        self._api.do('PATCH',
-                     f'/api/2.1/unity-catalog/workspaces/{workspace_id}/metastore',
-                     body=body,
-                     headers=headers)
+        headers = {'Accept': 'application/json', }
 
+        self._api.do('DELETE', f'/api/2.0/online-tables/{name}', headers=headers)
 
-class ModelVersionsAPI:
-    """Databricks provides a hosted version of MLflow Model Registry in Unity Catalog. Models in Unity Catalog
-    provide centralized access control, auditing, lineage, and discovery of ML models across Databricks
-    workspaces.
+    def get(self, name: str) -> OnlineTable:
+        """Get an Online Table.
+        
+        Get information about an existing online table and its status.
+        
+        :param name: str
+          Full three-part (catalog, schema, table) name of the table.
+        
+        :returns: :class:`OnlineTable`
+        """
+
+        headers = {'Accept': 'application/json', }
+
+        res = self._api.do('GET', f'/api/2.0/online-tables/{name}', headers=headers)
+        return OnlineTable.from_dict(res)
+
+
+class QualityMonitorsAPI:
+    """A monitor computes and monitors data or model quality metrics for a table over time. It generates metrics
+    tables and a dashboard that you can use to monitor table health and set alerts.
     
-    This API reference documents the REST endpoints for managing model versions in Unity Catalog. For more
-    details, see the [registered models API docs](/api/workspace/registeredmodels)."""
+    Most write operations require the user to be the owner of the table (or its parent schema or parent
+    catalog). Viewing the dashboard, computed metrics, or monitor configuration only requires the user to have
+    **SELECT** privileges on the table (along with **USE_SCHEMA** and **USE_CATALOG**)."""
 
     def __init__(self, api_client):
         self._api = api_client
 
-    def delete(self, full_name: str, version: int):
-        """Delete a Model Version.
+    def cancel_refresh(self, table_name: str, refresh_id: str):
+        """Cancel refresh.
         
-        Deletes a model version from the specified registered model. Any aliases assigned to the model version
-        will also be deleted.
+        Cancel an active monitor refresh for the given refresh ID.
         
-        The caller must be a metastore admin or an owner of the parent registered model. For the latter case,
-        the caller must also be the owner or have the **USE_CATALOG** privilege on the parent catalog and the
-        **USE_SCHEMA** privilege on the parent schema.
+        The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
+        table's parent catalog and be an owner of the table's parent schema 3. have the following permissions:
+        - **USE_CATALOG** on the table's parent catalog - **USE_SCHEMA** on the table's parent schema - be an
+        owner of the table
         
-        :param full_name: str
-          The three-level (fully qualified) name of the model version
-        :param version: int
-          The integer version number of the model version
+        Additionally, the call must be made from the workspace where the monitor was created.
+        
+        :param table_name: str
+          Full name of the table.
+        :param refresh_id: str
+          ID of the refresh.
         
         
         """
 
         headers = {}
 
-        self._api.do('DELETE',
-                     f'/api/2.1/unity-catalog/models/{full_name}/versions/{version}',
+        self._api.do('POST',
+                     f'/api/2.1/unity-catalog/tables/{table_name}/monitor/refreshes/{refresh_id}/cancel',
                      headers=headers)
 
-    def get(self,
-            full_name: str,
-            version: int,
-            *,
-            include_browse: Optional[bool] = None) -> RegisteredModelInfo:
-        """Get a Model Version.
+    def create(self,
+               table_name: str,
+               assets_dir: str,
+               output_schema_name: str,
+               *,
+               baseline_table_name: Optional[str] = None,
+               custom_metrics: Optional[List[MonitorMetric]] = None,
+               data_classification_config: Optional[MonitorDataClassificationConfig] = None,
+               inference_log: Optional[MonitorInferenceLog] = None,
+               notifications: Optional[MonitorNotifications] = None,
+               schedule: Optional[MonitorCronSchedule] = None,
+               skip_builtin_dashboard: Optional[bool] = None,
+               slicing_exprs: Optional[List[str]] = None,
+               snapshot: Optional[MonitorSnapshot] = None,
+               time_series: Optional[MonitorTimeSeries] = None,
+               warehouse_id: Optional[str] = None) -> MonitorInfo:
+        """Create a table monitor.
         
-        Get a model version.
+        Creates a new monitor for the specified table.
         
-        The caller must be a metastore admin or an owner of (or have the **EXECUTE** privilege on) the parent
-        registered model. For the latter case, the caller must also be the owner or have the **USE_CATALOG**
-        privilege on the parent catalog and the **USE_SCHEMA** privilege on the parent schema.
+        The caller must either: 1. be an owner of the table's parent catalog, have **USE_SCHEMA** on the
+        table's parent schema, and have **SELECT** access on the table 2. have **USE_CATALOG** on the table's
+        parent catalog, be an owner of the table's parent schema, and have **SELECT** access on the table. 3.
+        have the following permissions: - **USE_CATALOG** on the table's parent catalog - **USE_SCHEMA** on
+        the table's parent schema - be an owner of the table.
         
-        :param full_name: str
-          The three-level (fully qualified) name of the model version
-        :param version: int
-          The integer version number of the model version
-        :param include_browse: bool (optional)
-          Whether to include model versions in the response for which the principal can only access selective
-          metadata for
+        Workspace assets, such as the dashboard, will be created in the workspace where this call was made.
         
-        :returns: :class:`RegisteredModelInfo`
+        :param table_name: str
+          Full name of the table.
+        :param assets_dir: str
+          The directory to store monitoring assets (e.g. dashboard, metric tables).
+        :param output_schema_name: str
+          Schema where output metric tables are created.
+        :param baseline_table_name: str (optional)
+          Name of the baseline table from which drift metrics are computed from. Columns in the monitored
+          table should also be present in the baseline table.
+        :param custom_metrics: List[:class:`MonitorMetric`] (optional)
+          Custom metrics to compute on the monitored table. These can be aggregate metrics, derived metrics
+          (from already computed aggregate metrics), or drift metrics (comparing metrics across time windows).
+        :param data_classification_config: :class:`MonitorDataClassificationConfig` (optional)
+          The data classification config for the monitor.
+        :param inference_log: :class:`MonitorInferenceLog` (optional)
+          Configuration for monitoring inference logs.
+        :param notifications: :class:`MonitorNotifications` (optional)
+          The notification settings for the monitor.
+        :param schedule: :class:`MonitorCronSchedule` (optional)
+          The schedule for automatically updating and refreshing metric tables.
+        :param skip_builtin_dashboard: bool (optional)
+          Whether to skip creating a default dashboard summarizing data quality metrics.
+        :param slicing_exprs: List[str] (optional)
+          List of column expressions to slice data with for targeted analysis. The data is grouped by each
+          expression independently, resulting in a separate slice for each predicate and its complements. For
+          high-cardinality columns, only the top 100 unique values by frequency will generate slices.
+        :param snapshot: :class:`MonitorSnapshot` (optional)
+          Configuration for monitoring snapshot tables.
+        :param time_series: :class:`MonitorTimeSeries` (optional)
+          Configuration for monitoring time series tables.
+        :param warehouse_id: str (optional)
+          Optional argument to specify the warehouse for dashboard creation. If not specified, the first
+          running warehouse will be used.
+        
+        :returns: :class:`MonitorInfo`
         """
+        body = {}
+        if assets_dir is not None: body['assets_dir'] = assets_dir
+        if baseline_table_name is not None: body['baseline_table_name'] = baseline_table_name
+        if custom_metrics is not None: body['custom_metrics'] = [v.as_dict() for v in custom_metrics]
+        if data_classification_config is not None:
+            body['data_classification_config'] = data_classification_config.as_dict()
+        if inference_log is not None: body['inference_log'] = inference_log.as_dict()
+        if notifications is not None: body['notifications'] = notifications.as_dict()
+        if output_schema_name is not None: body['output_schema_name'] = output_schema_name
+        if schedule is not None: body['schedule'] = schedule.as_dict()
+        if skip_builtin_dashboard is not None: body['skip_builtin_dashboard'] = skip_builtin_dashboard
+        if slicing_exprs is not None: body['slicing_exprs'] = [v for v in slicing_exprs]
+        if snapshot is not None: body['snapshot'] = snapshot.as_dict()
+        if time_series is not None: body['time_series'] = time_series.as_dict()
+        if warehouse_id is not None: body['warehouse_id'] = warehouse_id
+        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
-        query = {}
-        if include_browse is not None: query['include_browse'] = include_browse
-        headers = {'Accept': 'application/json', }
-
-        res = self._api.do('GET',
-                           f'/api/2.1/unity-catalog/models/{full_name}/versions/{version}',
-                           query=query,
+        res = self._api.do('POST',
+                           f'/api/2.1/unity-catalog/tables/{table_name}/monitor',
+                           body=body,
                            headers=headers)
-        return RegisteredModelInfo.from_dict(res)
+        return MonitorInfo.from_dict(res)
 
-    def get_by_alias(self, full_name: str, alias: str) -> ModelVersionInfo:
-        """Get Model Version By Alias.
+    def delete(self, table_name: str):
+        """Delete a table monitor.
         
-        Get a model version by alias.
+        Deletes a monitor for the specified table.
         
-        The caller must be a metastore admin or an owner of (or have the **EXECUTE** privilege on) the
-        registered model. For the latter case, the caller must also be the owner or have the **USE_CATALOG**
-        privilege on the parent catalog and the **USE_SCHEMA** privilege on the parent schema.
+        The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
+        table's parent catalog and be an owner of the table's parent schema 3. have the following permissions:
+        - **USE_CATALOG** on the table's parent catalog - **USE_SCHEMA** on the table's parent schema - be an
+        owner of the table.
+        
+        Additionally, the call must be made from the workspace where the monitor was created.
+        
+        Note that the metric tables and dashboard will not be deleted as part of this call; those assets must
+        be manually cleaned up (if desired).
+        
+        :param table_name: str
+          Full name of the table.
         
-        :param full_name: str
-          The three-level (fully qualified) name of the registered model
-        :param alias: str
-          The name of the alias
         
-        :returns: :class:`ModelVersionInfo`
         """
 
-        headers = {'Accept': 'application/json', }
+        headers = {}
 
-        res = self._api.do('GET',
-                           f'/api/2.1/unity-catalog/models/{full_name}/aliases/{alias}',
-                           headers=headers)
-        return ModelVersionInfo.from_dict(res)
+        self._api.do('DELETE', f'/api/2.1/unity-catalog/tables/{table_name}/monitor', headers=headers)
 
-    def list(self,
-             full_name: str,
-             *,
-             include_browse: Optional[bool] = None,
-             max_results: Optional[int] = None,
-             page_token: Optional[str] = None) -> Iterator[ModelVersionInfo]:
-        """List Model Versions.
+    def get(self, table_name: str) -> MonitorInfo:
+        """Get a table monitor.
         
-        List model versions. You can list model versions under a particular schema, or list all model versions
-        in the current metastore.
+        Gets a monitor for the specified table.
         
-        The returned models are filtered based on the privileges of the calling user. For example, the
-        metastore admin is able to list all the model versions. A regular user needs to be the owner or have
-        the **EXECUTE** privilege on the parent registered model to recieve the model versions in the
-        response. For the latter case, the caller must also be the owner or have the **USE_CATALOG** privilege
-        on the parent catalog and the **USE_SCHEMA** privilege on the parent schema.
+        The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
+        table's parent catalog and be an owner of the table's parent schema. 3. have the following
+        permissions: - **USE_CATALOG** on the table's parent catalog - **USE_SCHEMA** on the table's parent
+        schema - **SELECT** privilege on the table.
         
-        There is no guarantee of a specific ordering of the elements in the response. The elements in the
-        response will not contain any aliases or tags.
+        The returned information includes configuration values, as well as information on assets created by
+        the monitor. Some information (e.g., dashboard) may be filtered out if the caller is in a different
+        workspace than where the monitor was created.
         
-        :param full_name: str
-          The full three-level name of the registered model under which to list model versions
-        :param include_browse: bool (optional)
-          Whether to include model versions in the response for which the principal can only access selective
-          metadata for
-        :param max_results: int (optional)
-          Maximum number of model versions to return. If not set, the page length is set to a server
-          configured value (100, as of 1/3/2024). - when set to a value greater than 0, the page length is the
-          minimum of this value and a server configured value(1000, as of 1/3/2024); - when set to 0, the page
-          length is set to a server configured value (100, as of 1/3/2024) (recommended); - when set to a
-          value less than 0, an invalid parameter error is returned;
-        :param page_token: str (optional)
-          Opaque pagination token to go to next page based on previous query.
+        :param table_name: str
+          Full name of the table.
         
-        :returns: Iterator over :class:`ModelVersionInfo`
+        :returns: :class:`MonitorInfo`
         """
 
-        query = {}
-        if include_browse is not None: query['include_browse'] = include_browse
-        if max_results is not None: query['max_results'] = max_results
-        if page_token is not None: query['page_token'] = page_token
         headers = {'Accept': 'application/json', }
 
-        while True:
-            json = self._api.do('GET',
-                                f'/api/2.1/unity-catalog/models/{full_name}/versions',
-                                query=query,
-                                headers=headers)
-            if 'model_versions' in json:
-                for v in json['model_versions']:
-                    yield ModelVersionInfo.from_dict(v)
-            if 'next_page_token' not in json or not json['next_page_token']:
-                return
-            query['page_token'] = json['next_page_token']
+        res = self._api.do('GET', f'/api/2.1/unity-catalog/tables/{table_name}/monitor', headers=headers)
+        return MonitorInfo.from_dict(res)
 
-    def update(self, full_name: str, version: int, *, comment: Optional[str] = None) -> ModelVersionInfo:
-        """Update a Model Version.
+    def get_refresh(self, table_name: str, refresh_id: str) -> MonitorRefreshInfo:
+        """Get refresh.
         
-        Updates the specified model version.
+        Gets info about a specific monitor refresh using the given refresh ID.
         
-        The caller must be a metastore admin or an owner of the parent registered model. For the latter case,
-        the caller must also be the owner or have the **USE_CATALOG** privilege on the parent catalog and the
-        **USE_SCHEMA** privilege on the parent schema.
+        The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
+        table's parent catalog and be an owner of the table's parent schema 3. have the following permissions:
+        - **USE_CATALOG** on the table's parent catalog - **USE_SCHEMA** on the table's parent schema -
+        **SELECT** privilege on the table.
         
-        Currently only the comment of the model version can be updated.
+        Additionally, the call must be made from the workspace where the monitor was created.
         
-        :param full_name: str
-          The three-level (fully qualified) name of the model version
-        :param version: int
-          The integer version number of the model version
-        :param comment: str (optional)
-          The comment attached to the model version
+        :param table_name: str
+          Full name of the table.
+        :param refresh_id: str
+          ID of the refresh.
         
-        :returns: :class:`ModelVersionInfo`
+        :returns: :class:`MonitorRefreshInfo`
         """
-        body = {}
-        if comment is not None: body['comment'] = comment
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
-
-        res = self._api.do('PATCH',
-                           f'/api/2.1/unity-catalog/models/{full_name}/versions/{version}',
-                           body=body,
-                           headers=headers)
-        return ModelVersionInfo.from_dict(res)
-
 
-class OnlineTablesAPI:
-    """Online tables provide lower latency and higher QPS access to data from Delta tables."""
+        headers = {'Accept': 'application/json', }
 
-    def __init__(self, api_client):
-        self._api = api_client
+        res = self._api.do('GET',
+                           f'/api/2.1/unity-catalog/tables/{table_name}/monitor/refreshes/{refresh_id}',
+                           headers=headers)
+        return MonitorRefreshInfo.from_dict(res)
 
-    def create(self, *, name: Optional[str] = None, spec: Optional[OnlineTableSpec] = None) -> OnlineTable:
-        """Create an Online Table.
+    def list_refreshes(self, table_name: str) -> MonitorRefreshListResponse:
+        """List refreshes.
         
-        Create a new Online Table.
+        Gets an array containing the history of the most recent refreshes (up to 25) for this table.
         
-        :param name: str (optional)
-          Full three-part (catalog, schema, table) name of the table.
-        :param spec: :class:`OnlineTableSpec` (optional)
-          Specification of the online table.
+        The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
+        table's parent catalog and be an owner of the table's parent schema 3. have the following permissions:
+        - **USE_CATALOG** on the table's parent catalog - **USE_SCHEMA** on the table's parent schema -
+        **SELECT** privilege on the table.
         
-        :returns: :class:`OnlineTable`
+        Additionally, the call must be made from the workspace where the monitor was created.
+        
+        :param table_name: str
+          Full name of the table.
+        
+        :returns: :class:`MonitorRefreshListResponse`
         """
-        body = {}
-        if name is not None: body['name'] = name
-        if spec is not None: body['spec'] = spec.as_dict()
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
-        res = self._api.do('POST', '/api/2.0/online-tables', body=body, headers=headers)
-        return OnlineTable.from_dict(res)
+        headers = {'Accept': 'application/json', }
 
-    def delete(self, name: str):
-        """Delete an Online Table.
+        res = self._api.do('GET',
+                           f'/api/2.1/unity-catalog/tables/{table_name}/monitor/refreshes',
+                           headers=headers)
+        return MonitorRefreshListResponse.from_dict(res)
+
+    def run_refresh(self, table_name: str) -> MonitorRefreshInfo:
+        """Queue a metric refresh for a monitor.
         
-        Delete an online table. Warning: This will delete all the data in the online table. If the source
-        Delta table was deleted or modified since this Online Table was created, this will lose the data
-        forever!
+        Queues a metric refresh on the monitor for the specified table. The refresh will execute in the
+        background.
         
-        :param name: str
-          Full three-part (catalog, schema, table) name of the table.
+        The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
+        table's parent catalog and be an owner of the table's parent schema 3. have the following permissions:
+        - **USE_CATALOG** on the table's parent catalog - **USE_SCHEMA** on the table's parent schema - be an
+        owner of the table
         
+        Additionally, the call must be made from the workspace where the monitor was created.
+        
+        :param table_name: str
+          Full name of the table.
         
+        :returns: :class:`MonitorRefreshInfo`
         """
 
         headers = {'Accept': 'application/json', }
 
-        self._api.do('DELETE', f'/api/2.0/online-tables/{name}', headers=headers)
+        res = self._api.do('POST',
+                           f'/api/2.1/unity-catalog/tables/{table_name}/monitor/refreshes',
+                           headers=headers)
+        return MonitorRefreshInfo.from_dict(res)
 
-    def get(self, name: str) -> OnlineTable:
-        """Get an Online Table.
+    def update(self,
+               table_name: str,
+               output_schema_name: str,
+               *,
+               baseline_table_name: Optional[str] = None,
+               custom_metrics: Optional[List[MonitorMetric]] = None,
+               dashboard_id: Optional[str] = None,
+               data_classification_config: Optional[MonitorDataClassificationConfig] = None,
+               inference_log: Optional[MonitorInferenceLog] = None,
+               notifications: Optional[MonitorNotifications] = None,
+               schedule: Optional[MonitorCronSchedule] = None,
+               slicing_exprs: Optional[List[str]] = None,
+               snapshot: Optional[MonitorSnapshot] = None,
+               time_series: Optional[MonitorTimeSeries] = None) -> MonitorInfo:
+        """Update a table monitor.
         
-        Get information about an existing online table and its status.
+        Updates a monitor for the specified table.
         
-        :param name: str
-          Full three-part (catalog, schema, table) name of the table.
+        The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
+        table's parent catalog and be an owner of the table's parent schema 3. have the following permissions:
+        - **USE_CATALOG** on the table's parent catalog - **USE_SCHEMA** on the table's parent schema - be an
+        owner of the table.
         
-        :returns: :class:`OnlineTable`
+        Additionally, the call must be made from the workspace where the monitor was created, and the caller
+        must be the original creator of the monitor.
+        
+        Certain configuration fields, such as output asset identifiers, cannot be updated.
+        
+        :param table_name: str
+          Full name of the table.
+        :param output_schema_name: str
+          Schema where output metric tables are created.
+        :param baseline_table_name: str (optional)
+          Name of the baseline table from which drift metrics are computed from. Columns in the monitored
+          table should also be present in the baseline table.
+        :param custom_metrics: List[:class:`MonitorMetric`] (optional)
+          Custom metrics to compute on the monitored table. These can be aggregate metrics, derived metrics
+          (from already computed aggregate metrics), or drift metrics (comparing metrics across time windows).
+        :param dashboard_id: str (optional)
+          Id of dashboard that visualizes the computed metrics. This can be empty if the monitor is in PENDING
+          state.
+        :param data_classification_config: :class:`MonitorDataClassificationConfig` (optional)
+          The data classification config for the monitor.
+        :param inference_log: :class:`MonitorInferenceLog` (optional)
+          Configuration for monitoring inference logs.
+        :param notifications: :class:`MonitorNotifications` (optional)
+          The notification settings for the monitor.
+        :param schedule: :class:`MonitorCronSchedule` (optional)
+          The schedule for automatically updating and refreshing metric tables.
+        :param slicing_exprs: List[str] (optional)
+          List of column expressions to slice data with for targeted analysis. The data is grouped by each
+          expression independently, resulting in a separate slice for each predicate and its complements. For
+          high-cardinality columns, only the top 100 unique values by frequency will generate slices.
+        :param snapshot: :class:`MonitorSnapshot` (optional)
+          Configuration for monitoring snapshot tables.
+        :param time_series: :class:`MonitorTimeSeries` (optional)
+          Configuration for monitoring time series tables.
+        
+        :returns: :class:`MonitorInfo`
         """
+        body = {}
+        if baseline_table_name is not None: body['baseline_table_name'] = baseline_table_name
+        if custom_metrics is not None: body['custom_metrics'] = [v.as_dict() for v in custom_metrics]
+        if dashboard_id is not None: body['dashboard_id'] = dashboard_id
+        if data_classification_config is not None:
+            body['data_classification_config'] = data_classification_config.as_dict()
+        if inference_log is not None: body['inference_log'] = inference_log.as_dict()
+        if notifications is not None: body['notifications'] = notifications.as_dict()
+        if output_schema_name is not None: body['output_schema_name'] = output_schema_name
+        if schedule is not None: body['schedule'] = schedule.as_dict()
+        if slicing_exprs is not None: body['slicing_exprs'] = [v for v in slicing_exprs]
+        if snapshot is not None: body['snapshot'] = snapshot.as_dict()
+        if time_series is not None: body['time_series'] = time_series.as_dict()
+        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
-        headers = {'Accept': 'application/json', }
-
-        res = self._api.do('GET', f'/api/2.0/online-tables/{name}', headers=headers)
-        return OnlineTable.from_dict(res)
+        res = self._api.do('PUT',
+                           f'/api/2.1/unity-catalog/tables/{table_name}/monitor',
+                           body=body,
+                           headers=headers)
+        return MonitorInfo.from_dict(res)
 
 
 class RegisteredModelsAPI:
@@ -8450,7 +8488,7 @@ class SystemSchemasAPI:
     def __init__(self, api_client):
         self._api = api_client
 
-    def disable(self, metastore_id: str, schema_name: DisableSchemaName):
+    def disable(self, metastore_id: str, schema_name: str):
         """Disable a system schema.
         
         Disables the system schema and removes it from the system catalog. The caller must be an account admin
@@ -8458,7 +8496,7 @@ class SystemSchemasAPI:
         
         :param metastore_id: str
           The metastore ID under which the system schema lives.
-        :param schema_name: :class:`DisableSchemaName`
+        :param schema_name: str
           Full name of the system schema.
         
         
@@ -8467,10 +8505,10 @@ class SystemSchemasAPI:
         headers = {'Accept': 'application/json', }
 
         self._api.do('DELETE',
-                     f'/api/2.1/unity-catalog/metastores/{metastore_id}/systemschemas/{schema_name.value}',
+                     f'/api/2.1/unity-catalog/metastores/{metastore_id}/systemschemas/{schema_name}',
                      headers=headers)
 
-    def enable(self, metastore_id: str, schema_name: EnableSchemaName):
+    def enable(self, metastore_id: str, schema_name: str):
         """Enable a system schema.
         
         Enables the system schema and adds it to the system catalog. The caller must be an account admin or a
@@ -8478,7 +8516,7 @@ class SystemSchemasAPI:
         
         :param metastore_id: str
           The metastore ID under which the system schema lives.
-        :param schema_name: :class:`EnableSchemaName`
+        :param schema_name: str
           Full name of the system schema.
         
         
@@ -8487,7 +8525,7 @@ class SystemSchemasAPI:
         headers = {'Accept': 'application/json', }
 
         self._api.do('PUT',
-                     f'/api/2.1/unity-catalog/metastores/{metastore_id}/systemschemas/{schema_name.value}',
+                     f'/api/2.1/unity-catalog/metastores/{metastore_id}/systemschemas/{schema_name}',
                      headers=headers)
 
     def list(self, metastore_id: str) -> Iterator[SystemSchemaInfo]: