databricks-sdk 0.17.0__py3-none-any.whl → 0.19.0__py3-none-any.whl

databricks/sdk/service/catalog.py

@@ -784,6 +784,7 @@ class ConnectionInfoSecurableKind(Enum):
 class ConnectionType(Enum):
     """The type of connection."""
 
+    BIGQUERY = 'BIGQUERY'
     DATABRICKS = 'DATABRICKS'
     MYSQL = 'MYSQL'
     POSTGRESQL = 'POSTGRESQL'
@@ -1162,6 +1163,97 @@ class CreateMetastoreAssignment:
                    workspace_id=d.get('workspace_id', None))
 
 
+@dataclass
+class CreateMonitor:
+    assets_dir: str
+    """The directory to store monitoring assets (e.g. dashboard, metric tables)."""
+
+    output_schema_name: str
+    """Schema where output metric tables are created."""
+
+    baseline_table_name: Optional[str] = None
+    """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."""
+
+    custom_metrics: Optional[List[MonitorCustomMetric]] = None
+    """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)."""
+
+    data_classification_config: Optional[MonitorDataClassificationConfig] = None
+    """The data classification config for the monitor."""
+
+    full_name: Optional[str] = None
+    """Full name of the table."""
+
+    inference_log: Optional[MonitorInferenceLogProfileType] = None
+    """Configuration for monitoring inference logs."""
+
+    notifications: Optional[List[MonitorNotificationsConfig]] = None
+    """The notification settings for the monitor."""
+
+    schedule: Optional[MonitorCronSchedule] = None
+    """The schedule for automatically updating and refreshing metric tables."""
+
+    skip_builtin_dashboard: Optional[bool] = None
+    """Whether to skip creating a default dashboard summarizing data quality metrics."""
+
+    slicing_exprs: Optional[List[str]] = None
+    """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."""
+
+    snapshot: Optional[Any] = None
+    """Configuration for monitoring snapshot tables."""
+
+    time_series: Optional[MonitorTimeSeriesProfileType] = None
+    """Configuration for monitoring time series tables."""
+
+    warehouse_id: Optional[str] = None
+    """Optional argument to specify the warehouse for dashboard creation. If not specified, the first
+    running warehouse will be used."""
+
+    def as_dict(self) -> dict:
+        """Serializes the CreateMonitor into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.assets_dir is not None: body['assets_dir'] = self.assets_dir
+        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.data_classification_config:
+            body['data_classification_config'] = self.data_classification_config.as_dict()
+        if self.full_name is not None: body['full_name'] = self.full_name
+        if self.inference_log: body['inference_log'] = self.inference_log.as_dict()
+        if self.notifications: body['notifications'] = [v.as_dict() for v in self.notifications]
+        if self.output_schema_name is not None: body['output_schema_name'] = self.output_schema_name
+        if self.schedule: body['schedule'] = self.schedule.as_dict()
+        if self.skip_builtin_dashboard is not None:
+            body['skip_builtin_dashboard'] = self.skip_builtin_dashboard
+        if self.slicing_exprs: body['slicing_exprs'] = [v for v in self.slicing_exprs]
+        if self.snapshot: body['snapshot'] = self.snapshot
+        if self.time_series: body['time_series'] = self.time_series.as_dict()
+        if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> CreateMonitor:
+        """Deserializes the CreateMonitor from a dictionary."""
+        return cls(assets_dir=d.get('assets_dir', None),
+                   baseline_table_name=d.get('baseline_table_name', None),
+                   custom_metrics=_repeated_dict(d, 'custom_metrics', MonitorCustomMetric),
+                   data_classification_config=_from_dict(d, 'data_classification_config',
+                                                         MonitorDataClassificationConfig),
+                   full_name=d.get('full_name', None),
+                   inference_log=_from_dict(d, 'inference_log', MonitorInferenceLogProfileType),
+                   notifications=_repeated_dict(d, 'notifications', MonitorNotificationsConfig),
+                   output_schema_name=d.get('output_schema_name', None),
+                   schedule=_from_dict(d, 'schedule', MonitorCronSchedule),
+                   skip_builtin_dashboard=d.get('skip_builtin_dashboard', None),
+                   slicing_exprs=d.get('slicing_exprs', None),
+                   snapshot=d.get('snapshot', None),
+                   time_series=_from_dict(d, 'time_series', MonitorTimeSeriesProfileType),
+                   warehouse_id=d.get('warehouse_id', None))
+
+
 @dataclass
 class CreateRegisteredModelRequest:
     catalog_name: str
@@ -2731,6 +2823,389 @@ class ModelVersionInfoStatus(Enum):
     READY = 'READY'
 
 
+@dataclass
+class MonitorCronSchedule:
+    pause_status: Optional[MonitorCronSchedulePauseStatus] = None
+    """Whether the schedule is paused or not"""
+
+    quartz_cron_expression: Optional[str] = None
+    """A cron expression using quartz syntax that describes the schedule for a job."""
+
+    timezone_id: Optional[str] = None
+    """A Java timezone id. The schedule for a job will be resolved with respect to this timezone."""
+
+    def as_dict(self) -> dict:
+        """Serializes the MonitorCronSchedule into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.pause_status is not None: body['pause_status'] = self.pause_status.value
+        if self.quartz_cron_expression is not None:
+            body['quartz_cron_expression'] = self.quartz_cron_expression
+        if self.timezone_id is not None: body['timezone_id'] = self.timezone_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> MonitorCronSchedule:
+        """Deserializes the MonitorCronSchedule from a dictionary."""
+        return cls(pause_status=_enum(d, 'pause_status', MonitorCronSchedulePauseStatus),
+                   quartz_cron_expression=d.get('quartz_cron_expression', None),
+                   timezone_id=d.get('timezone_id', None))
+
+
+class MonitorCronSchedulePauseStatus(Enum):
+    """Whether the schedule is paused or not"""
+
+    PAUSED = 'PAUSED'
+    UNPAUSED = 'UNPAUSED'
+
+
+@dataclass
+class MonitorCustomMetric:
+    definition: Optional[str] = None
+    """Jinja template for a SQL expression that specifies how to compute the metric. See [create metric
+    definition].
+    
+    [create metric definition]: https://docs.databricks.com/en/lakehouse-monitoring/custom-metrics.html#create-definition"""
+
+    input_columns: Optional[List[str]] = None
+    """Columns on the monitored table to apply the custom metrics to."""
+
+    name: Optional[str] = None
+    """Name of the custom metric."""
+
+    output_data_type: Optional[str] = None
+    """The output type of the custom metric."""
+
+    type: Optional[MonitorCustomMetricType] = None
+    """The type of the custom metric."""
+
+    def as_dict(self) -> dict:
+        """Serializes the MonitorCustomMetric into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.definition is not None: body['definition'] = self.definition
+        if self.input_columns: body['input_columns'] = [v for v in self.input_columns]
+        if self.name is not None: body['name'] = self.name
+        if self.output_data_type is not None: body['output_data_type'] = self.output_data_type
+        if self.type is not None: body['type'] = self.type.value
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> MonitorCustomMetric:
+        """Deserializes the MonitorCustomMetric from a dictionary."""
+        return cls(definition=d.get('definition', None),
+                   input_columns=d.get('input_columns', None),
+                   name=d.get('name', None),
+                   output_data_type=d.get('output_data_type', None),
+                   type=_enum(d, 'type', MonitorCustomMetricType))
+
+
+class MonitorCustomMetricType(Enum):
+    """The type of the custom metric."""
+
+    CUSTOM_METRIC_TYPE_AGGREGATE = 'CUSTOM_METRIC_TYPE_AGGREGATE'
+    CUSTOM_METRIC_TYPE_DERIVED = 'CUSTOM_METRIC_TYPE_DERIVED'
+    CUSTOM_METRIC_TYPE_DRIFT = 'CUSTOM_METRIC_TYPE_DRIFT'
+    MONITOR_STATUS_ERROR = 'MONITOR_STATUS_ERROR'
+    MONITOR_STATUS_FAILED = 'MONITOR_STATUS_FAILED'
+
+
+@dataclass
+class MonitorDataClassificationConfig:
+    enabled: Optional[bool] = None
+    """Whether data classification is enabled."""
+
+    def as_dict(self) -> dict:
+        """Serializes the MonitorDataClassificationConfig into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.enabled is not None: body['enabled'] = self.enabled
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> MonitorDataClassificationConfig:
+        """Deserializes the MonitorDataClassificationConfig from a dictionary."""
+        return cls(enabled=d.get('enabled', None))
+
+
+@dataclass
+class MonitorDestinations:
+    email_addresses: Optional[List[str]] = None
+    """The list of email addresses to send the notification to."""
+
+    def as_dict(self) -> dict:
+        """Serializes the MonitorDestinations into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.email_addresses: body['email_addresses'] = [v for v in self.email_addresses]
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> MonitorDestinations:
+        """Deserializes the MonitorDestinations from a dictionary."""
+        return cls(email_addresses=d.get('email_addresses', None))
+
+
+@dataclass
+class MonitorInferenceLogProfileType:
+    granularities: Optional[List[str]] = None
+    """List of granularities to use when aggregating data into time windows based on their timestamp."""
+
+    label_col: Optional[str] = None
+    """Column of the model label."""
+
+    model_id_col: Optional[str] = None
+    """Column of the model id or version."""
+
+    prediction_col: Optional[str] = None
+    """Column of the model prediction."""
+
+    prediction_proba_col: Optional[str] = None
+    """Column of the model prediction probabilities."""
+
+    problem_type: Optional[MonitorInferenceLogProfileTypeProblemType] = None
+    """Problem type the model aims to solve."""
+
+    timestamp_col: Optional[str] = None
+    """Column of the timestamp of predictions."""
+
+    def as_dict(self) -> dict:
+        """Serializes the MonitorInferenceLogProfileType into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.granularities: body['granularities'] = [v for v in self.granularities]
+        if self.label_col is not None: body['label_col'] = self.label_col
+        if self.model_id_col is not None: body['model_id_col'] = self.model_id_col
+        if self.prediction_col is not None: body['prediction_col'] = self.prediction_col
+        if self.prediction_proba_col is not None: body['prediction_proba_col'] = self.prediction_proba_col
+        if self.problem_type is not None: body['problem_type'] = self.problem_type.value
+        if self.timestamp_col is not None: body['timestamp_col'] = self.timestamp_col
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> MonitorInferenceLogProfileType:
+        """Deserializes the MonitorInferenceLogProfileType from a dictionary."""
+        return cls(granularities=d.get('granularities', None),
+                   label_col=d.get('label_col', None),
+                   model_id_col=d.get('model_id_col', None),
+                   prediction_col=d.get('prediction_col', None),
+                   prediction_proba_col=d.get('prediction_proba_col', None),
+                   problem_type=_enum(d, 'problem_type', MonitorInferenceLogProfileTypeProblemType),
+                   timestamp_col=d.get('timestamp_col', None))
+
+
+class MonitorInferenceLogProfileTypeProblemType(Enum):
+    """Problem type the model aims to solve."""
+
+    PROBLEM_TYPE_CLASSIFICATION = 'PROBLEM_TYPE_CLASSIFICATION'
+    PROBLEM_TYPE_REGRESSION = 'PROBLEM_TYPE_REGRESSION'
+
+
+@dataclass
+class MonitorInfo:
+    assets_dir: Optional[str] = None
+    """The directory to store monitoring assets (e.g. dashboard, metric tables)."""
+
+    baseline_table_name: Optional[str] = None
+    """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."""
+
+    custom_metrics: Optional[List[MonitorCustomMetric]] = None
+    """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)."""
+
+    dashboard_id: Optional[str] = None
+    """The ID of the generated dashboard."""
+
+    data_classification_config: Optional[MonitorDataClassificationConfig] = None
+    """The data classification config for the monitor."""
+
+    drift_metrics_table_name: Optional[str] = None
+    """The full name of the drift metrics table. Format:
+    __catalog_name__.__schema_name__.__table_name__."""
+
+    inference_log: Optional[MonitorInferenceLogProfileType] = None
+    """Configuration for monitoring inference logs."""
+
+    latest_monitor_failure_msg: Optional[str] = None
+    """The latest failure message of the monitor (if any)."""
+
+    monitor_version: Optional[str] = None
+    """The version of the monitor config (e.g. 1,2,3). If negative, the monitor may be corrupted."""
+
+    notifications: Optional[List[MonitorNotificationsConfig]] = None
+    """The notification settings for the monitor."""
+
+    output_schema_name: Optional[str] = None
+    """Schema where output metric tables are created."""
+
+    profile_metrics_table_name: Optional[str] = None
+    """The full name of the profile metrics table. Format:
+    __catalog_name__.__schema_name__.__table_name__."""
+
+    schedule: Optional[MonitorCronSchedule] = None
+    """The schedule for automatically updating and refreshing metric tables."""
+
+    slicing_exprs: Optional[List[str]] = None
+    """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."""
+
+    snapshot: Optional[Any] = None
+    """Configuration for monitoring snapshot tables."""
+
+    status: Optional[MonitorInfoStatus] = None
+    """The status of the monitor."""
+
+    table_name: Optional[str] = None
+    """The full name of the table to monitor. Format: __catalog_name__.__schema_name__.__table_name__."""
+
+    time_series: Optional[MonitorTimeSeriesProfileType] = None
+    """Configuration for monitoring time series tables."""
+
+    def as_dict(self) -> dict:
+        """Serializes the MonitorInfo into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.assets_dir is not None: body['assets_dir'] = self.assets_dir
+        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.drift_metrics_table_name is not None:
+            body['drift_metrics_table_name'] = self.drift_metrics_table_name
+        if self.inference_log: body['inference_log'] = self.inference_log.as_dict()
+        if self.latest_monitor_failure_msg is not None:
+            body['latest_monitor_failure_msg'] = self.latest_monitor_failure_msg
+        if self.monitor_version is not None: body['monitor_version'] = self.monitor_version
+        if self.notifications: body['notifications'] = [v.as_dict() for v in self.notifications]
+        if self.output_schema_name is not None: body['output_schema_name'] = self.output_schema_name
+        if self.profile_metrics_table_name is not None:
+            body['profile_metrics_table_name'] = self.profile_metrics_table_name
+        if self.schedule: body['schedule'] = self.schedule.as_dict()
+        if self.slicing_exprs: body['slicing_exprs'] = [v for v in self.slicing_exprs]
+        if self.snapshot: body['snapshot'] = self.snapshot
+        if self.status is not None: body['status'] = self.status.value
+        if self.table_name is not None: body['table_name'] = self.table_name
+        if self.time_series: body['time_series'] = self.time_series.as_dict()
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> MonitorInfo:
+        """Deserializes the MonitorInfo from a dictionary."""
+        return cls(assets_dir=d.get('assets_dir', None),
+                   baseline_table_name=d.get('baseline_table_name', None),
+                   custom_metrics=_repeated_dict(d, 'custom_metrics', MonitorCustomMetric),
+                   dashboard_id=d.get('dashboard_id', None),
+                   data_classification_config=_from_dict(d, 'data_classification_config',
+                                                         MonitorDataClassificationConfig),
+                   drift_metrics_table_name=d.get('drift_metrics_table_name', None),
+                   inference_log=_from_dict(d, 'inference_log', MonitorInferenceLogProfileType),
+                   latest_monitor_failure_msg=d.get('latest_monitor_failure_msg', None),
+                   monitor_version=d.get('monitor_version', None),
+                   notifications=_repeated_dict(d, 'notifications', MonitorNotificationsConfig),
+                   output_schema_name=d.get('output_schema_name', None),
+                   profile_metrics_table_name=d.get('profile_metrics_table_name', None),
+                   schedule=_from_dict(d, 'schedule', MonitorCronSchedule),
+                   slicing_exprs=d.get('slicing_exprs', None),
+                   snapshot=d.get('snapshot', None),
+                   status=_enum(d, 'status', MonitorInfoStatus),
+                   table_name=d.get('table_name', None),
+                   time_series=_from_dict(d, 'time_series', MonitorTimeSeriesProfileType))
+
+
+class MonitorInfoStatus(Enum):
+    """The status of the monitor."""
+
+    MONITOR_STATUS_ACTIVE = 'MONITOR_STATUS_ACTIVE'
+    MONITOR_STATUS_DELETE_PENDING = 'MONITOR_STATUS_DELETE_PENDING'
+    MONITOR_STATUS_ERROR = 'MONITOR_STATUS_ERROR'
+    MONITOR_STATUS_FAILED = 'MONITOR_STATUS_FAILED'
+    MONITOR_STATUS_PENDING = 'MONITOR_STATUS_PENDING'
+
+
+@dataclass
+class MonitorNotificationsConfig:
+    on_failure: Optional[MonitorDestinations] = None
+    """Who to send notifications to on monitor failure."""
+
+    def as_dict(self) -> dict:
+        """Serializes the MonitorNotificationsConfig into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.on_failure: body['on_failure'] = self.on_failure.as_dict()
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> MonitorNotificationsConfig:
+        """Deserializes the MonitorNotificationsConfig from a dictionary."""
+        return cls(on_failure=_from_dict(d, 'on_failure', MonitorDestinations))
+
+
+@dataclass
+class MonitorRefreshInfo:
+    end_time_ms: Optional[int] = None
+    """The time at which the refresh ended, in epoch milliseconds."""
+
+    message: Optional[str] = None
+    """An optional message to give insight into the current state of the job (e.g. FAILURE messages)."""
+
+    refresh_id: Optional[int] = None
+    """The ID of the refresh."""
+
+    start_time_ms: Optional[int] = None
+    """The time at which the refresh started, in epoch milliseconds."""
+
+    state: Optional[MonitorRefreshInfoState] = None
+    """The current state of the refresh."""
+
+    def as_dict(self) -> dict:
+        """Serializes the MonitorRefreshInfo into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.end_time_ms is not None: body['end_time_ms'] = self.end_time_ms
+        if self.message is not None: body['message'] = self.message
+        if self.refresh_id is not None: body['refresh_id'] = self.refresh_id
+        if self.start_time_ms is not None: body['start_time_ms'] = self.start_time_ms
+        if self.state is not None: body['state'] = self.state.value
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> MonitorRefreshInfo:
+        """Deserializes the MonitorRefreshInfo from a dictionary."""
+        return cls(end_time_ms=d.get('end_time_ms', None),
+                   message=d.get('message', None),
+                   refresh_id=d.get('refresh_id', None),
+                   start_time_ms=d.get('start_time_ms', None),
+                   state=_enum(d, 'state', MonitorRefreshInfoState))
+
+
+class MonitorRefreshInfoState(Enum):
+    """The current state of the refresh."""
+
+    CANCELED = 'CANCELED'
+    FAILED = 'FAILED'
+    PENDING = 'PENDING'
+    RUNNING = 'RUNNING'
+    SUCCESS = 'SUCCESS'
+
+
+@dataclass
+class MonitorTimeSeriesProfileType:
+    granularities: Optional[List[str]] = None
+    """List of granularities to use when aggregating data into time windows based on their timestamp."""
+
+    timestamp_col: Optional[str] = None
+    """The timestamp column. This must be timestamp types or convertible to timestamp types using the
+    pyspark to_timestamp function."""
+
+    def as_dict(self) -> dict:
+        """Serializes the MonitorTimeSeriesProfileType into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.granularities: body['granularities'] = [v for v in self.granularities]
+        if self.timestamp_col is not None: body['timestamp_col'] = self.timestamp_col
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> MonitorTimeSeriesProfileType:
+        """Deserializes the MonitorTimeSeriesProfileType from a dictionary."""
+        return cls(granularities=d.get('granularities', None), timestamp_col=d.get('timestamp_col', None))
+
+
 @dataclass
 class NamedTableConstraint:
     name: str
@@ -3386,6 +3861,23 @@ class TableDependency:
         return cls(table_full_name=d.get('table_full_name', None))
 
 
+@dataclass
+class TableExistsResponse:
+    table_exists: Optional[bool] = None
+    """Whether the table exists or not."""
+
+    def as_dict(self) -> dict:
+        """Serializes the TableExistsResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.table_exists is not None: body['table_exists'] = self.table_exists
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> TableExistsResponse:
+        """Deserializes the TableExistsResponse from a dictionary."""
+        return cls(table_exists=d.get('table_exists', None))
+
+
 @dataclass
 class TableInfo:
     access_point: Optional[str] = None
@@ -3671,9 +4163,6 @@ class UpdateConnection:
     options: Dict[str, str]
     """A map of key-value properties attached to the securable."""
 
-    name: Optional[str] = None
-    """Name of the connection."""
-
     name_arg: Optional[str] = None
     """Name of the connection."""
 
@@ -3686,7 +4175,6 @@ class UpdateConnection:
     def as_dict(self) -> dict:
         """Serializes the UpdateConnection into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.name is not None: body['name'] = self.name
         if self.name_arg is not None: body['name_arg'] = self.name_arg
         if self.new_name is not None: body['new_name'] = self.new_name
         if self.options: body['options'] = self.options
@@ -3696,8 +4184,7 @@ class UpdateConnection:
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateConnection:
         """Deserializes the UpdateConnection from a dictionary."""
-        return cls(name=d.get('name', None),
-                   name_arg=d.get('name_arg', None),
+        return cls(name_arg=d.get('name_arg', None),
                    new_name=d.get('new_name', None),
                    options=d.get('options', None),
                    owner=d.get('owner', None))
@@ -3807,9 +4294,6 @@ class UpdateMetastore:
     id: Optional[str] = None
     """Unique ID of the metastore."""
 
-    name: Optional[str] = None
-    """The user-specified name of the metastore."""
-
     new_name: Optional[str] = None
     """New name for the metastore."""
 
@@ -3832,7 +4316,6 @@ class UpdateMetastore:
                 'delta_sharing_recipient_token_lifetime_in_seconds'] = self.delta_sharing_recipient_token_lifetime_in_seconds
         if self.delta_sharing_scope is not None: body['delta_sharing_scope'] = self.delta_sharing_scope.value
         if self.id is not None: body['id'] = self.id
-        if self.name is not None: body['name'] = self.name
         if self.new_name is not None: body['new_name'] = self.new_name
         if self.owner is not None: body['owner'] = self.owner
         if self.privilege_model_version is not None:
@@ -3849,7 +4332,6 @@ class UpdateMetastore:
                        'delta_sharing_recipient_token_lifetime_in_seconds', None),
                    delta_sharing_scope=_enum(d, 'delta_sharing_scope', UpdateMetastoreDeltaSharingScope),
                    id=d.get('id', None),
-                   name=d.get('name', None),
                    new_name=d.get('new_name', None),
                    owner=d.get('owner', None),
                    privilege_model_version=d.get('privilege_model_version', None),
@@ -3917,6 +4399,85 @@ class UpdateModelVersionRequest:
                    version=d.get('version', None))
 
 
+@dataclass
+class UpdateMonitor:
+    assets_dir: str
+    """The directory to store monitoring assets (e.g. dashboard, metric tables)."""
+
+    output_schema_name: str
+    """Schema where output metric tables are created."""
+
+    baseline_table_name: Optional[str] = None
+    """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."""
+
+    custom_metrics: Optional[List[MonitorCustomMetric]] = None
+    """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)."""
+
+    data_classification_config: Optional[MonitorDataClassificationConfig] = None
+    """The data classification config for the monitor."""
+
+    full_name: Optional[str] = None
+    """Full name of the table."""
+
+    inference_log: Optional[MonitorInferenceLogProfileType] = None
+    """Configuration for monitoring inference logs."""
+
+    notifications: Optional[List[MonitorNotificationsConfig]] = None
+    """The notification settings for the monitor."""
+
+    schedule: Optional[MonitorCronSchedule] = None
+    """The schedule for automatically updating and refreshing metric tables."""
+
+    slicing_exprs: Optional[List[str]] = None
+    """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."""
+
+    snapshot: Optional[Any] = None
+    """Configuration for monitoring snapshot tables."""
+
+    time_series: Optional[MonitorTimeSeriesProfileType] = None
+    """Configuration for monitoring time series tables."""
+
+    def as_dict(self) -> dict:
+        """Serializes the UpdateMonitor into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.assets_dir is not None: body['assets_dir'] = self.assets_dir
+        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.data_classification_config:
+            body['data_classification_config'] = self.data_classification_config.as_dict()
+        if self.full_name is not None: body['full_name'] = self.full_name
+        if self.inference_log: body['inference_log'] = self.inference_log.as_dict()
+        if self.notifications: body['notifications'] = [v.as_dict() for v in self.notifications]
+        if self.output_schema_name is not None: body['output_schema_name'] = self.output_schema_name
+        if self.schedule: body['schedule'] = self.schedule.as_dict()
+        if self.slicing_exprs: body['slicing_exprs'] = [v for v in self.slicing_exprs]
+        if self.snapshot: body['snapshot'] = self.snapshot
+        if self.time_series: body['time_series'] = self.time_series.as_dict()
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> UpdateMonitor:
+        """Deserializes the UpdateMonitor from a dictionary."""
+        return cls(assets_dir=d.get('assets_dir', None),
+                   baseline_table_name=d.get('baseline_table_name', None),
+                   custom_metrics=_repeated_dict(d, 'custom_metrics', MonitorCustomMetric),
+                   data_classification_config=_from_dict(d, 'data_classification_config',
+                                                         MonitorDataClassificationConfig),
+                   full_name=d.get('full_name', None),
+                   inference_log=_from_dict(d, 'inference_log', MonitorInferenceLogProfileType),
+                   notifications=_repeated_dict(d, 'notifications', MonitorNotificationsConfig),
+                   output_schema_name=d.get('output_schema_name', None),
+                   schedule=_from_dict(d, 'schedule', MonitorCronSchedule),
+                   slicing_exprs=d.get('slicing_exprs', None),
+                   snapshot=d.get('snapshot', None),
+                   time_series=_from_dict(d, 'time_series', MonitorTimeSeriesProfileType))
+
+
 @dataclass
 class UpdatePermissions:
     changes: Optional[List[PermissionsChange]] = None
@@ -3952,9 +4513,6 @@ class UpdateRegisteredModelRequest:
     full_name: Optional[str] = None
     """The three-level (fully qualified) name of the registered model"""
 
-    name: Optional[str] = None
-    """The name of the registered model"""
-
     new_name: Optional[str] = None
     """New name for the registered model."""
 
@@ -3966,7 +4524,6 @@ class UpdateRegisteredModelRequest:
         body = {}
         if self.comment is not None: body['comment'] = self.comment
         if self.full_name is not None: body['full_name'] = self.full_name
-        if self.name is not None: body['name'] = self.name
         if self.new_name is not None: body['new_name'] = self.new_name
         if self.owner is not None: body['owner'] = self.owner
         return body
@@ -3976,7 +4533,6 @@ class UpdateRegisteredModelRequest:
         """Deserializes the UpdateRegisteredModelRequest from a dictionary."""
         return cls(comment=d.get('comment', None),
                    full_name=d.get('full_name', None),
-                   name=d.get('name', None),
                    new_name=d.get('new_name', None),
                    owner=d.get('owner', None))
 
@@ -3992,9 +4548,6 @@ class UpdateSchema:
     full_name: Optional[str] = None
     """Full name of the schema."""
 
-    name: Optional[str] = None
-    """Name of schema, relative to parent catalog."""
-
     new_name: Optional[str] = None
     """New name for the schema."""
 
@@ -4011,7 +4564,6 @@ class UpdateSchema:
         if self.enable_predictive_optimization is not None:
             body['enable_predictive_optimization'] = self.enable_predictive_optimization.value
         if self.full_name is not None: body['full_name'] = self.full_name
-        if self.name is not None: body['name'] = self.name
         if self.new_name is not None: body['new_name'] = self.new_name
         if self.owner is not None: body['owner'] = self.owner
         if self.properties: body['properties'] = self.properties
@@ -4024,7 +4576,6 @@ class UpdateSchema:
                    enable_predictive_optimization=_enum(d, 'enable_predictive_optimization',
                                                         EnablePredictiveOptimization),
                    full_name=d.get('full_name', None),
-                   name=d.get('name', None),
                    new_name=d.get('new_name', None),
                    owner=d.get('owner', None),
                    properties=d.get('properties', None))
@@ -4112,9 +4663,6 @@ class UpdateVolumeRequestContent:
     full_name_arg: Optional[str] = None
     """The three-level (fully qualified) name of the volume"""
 
-    name: Optional[str] = None
-    """The name of the volume"""
-
     new_name: Optional[str] = None
     """New name for the volume."""
 
@@ -4126,7 +4674,6 @@ class UpdateVolumeRequestContent:
         body = {}
         if self.comment is not None: body['comment'] = self.comment
         if self.full_name_arg is not None: body['full_name_arg'] = self.full_name_arg
-        if self.name is not None: body['name'] = self.name
         if self.new_name is not None: body['new_name'] = self.new_name
         if self.owner is not None: body['owner'] = self.owner
         return body
@@ -4136,7 +4683,6 @@ class UpdateVolumeRequestContent:
         """Deserializes the UpdateVolumeRequestContent from a dictionary."""
         return cls(comment=d.get('comment', None),
                    full_name_arg=d.get('full_name_arg', None),
-                   name=d.get('name', None),
                    new_name=d.get('new_name', None),
                    owner=d.get('owner', None))
 
@@ -5115,7 +5661,6 @@ class ConnectionsAPI:
                name_arg: str,
                options: Dict[str, str],
                *,
-               name: Optional[str] = None,
                new_name: Optional[str] = None,
                owner: Optional[str] = None) -> ConnectionInfo:
         """Update a connection.
@@ -5126,8 +5671,6 @@ class ConnectionsAPI:
           Name of the connection.
         :param options: Dict[str,str]
           A map of key-value properties attached to the securable.
-        :param name: str (optional)
-          Name of the connection.
         :param new_name: str (optional)
           New name for the connection.
         :param owner: str (optional)
@@ -5136,7 +5679,6 @@ class ConnectionsAPI:
         :returns: :class:`ConnectionInfo`
         """
         body = {}
-        if name is not None: body['name'] = name
         if new_name is not None: body['new_name'] = new_name
         if options is not None: body['options'] = options
         if owner is not None: body['owner'] = owner
@@ -5281,10 +5823,9 @@ class ExternalLocationsAPI:
                                 '/api/2.1/unity-catalog/external-locations',
                                 query=query,
                                 headers=headers)
-            if 'external_locations' not in json or not json['external_locations']:
-                return
-            for v in json['external_locations']:
-                yield ExternalLocationInfo.from_dict(v)
+            if 'external_locations' in json:
+                for v in json['external_locations']:
+                    yield ExternalLocationInfo.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
             query['page_token'] = json['next_page_token']
@@ -5465,10 +6006,9 @@ class FunctionsAPI:
 
         while True:
             json = self._api.do('GET', '/api/2.1/unity-catalog/functions', query=query, headers=headers)
-            if 'functions' not in json or not json['functions']:
-                return
-            for v in json['functions']:
-                yield FunctionInfo.from_dict(v)
+            if 'functions' in json:
+                for v in json['functions']:
+                    yield FunctionInfo.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
             query['page_token'] = json['next_page_token']
@@ -5597,6 +6137,331 @@ 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.
+    
+    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 cancel_refresh(self, full_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
+        
+        Additionally, the call must be made from the workspace where the monitor was created.
+        
+        :param full_name: str
+          Full name of the table.
+        :param refresh_id: str
+          ID of the refresh.
+        
+        
+        """
+
+        headers = {}
+        self._api.do('POST',
+                     f'/api/2.1/unity-catalog/tables/{full_name}/monitor/refreshes/{refresh_id}/cancel',
+                     headers=headers)
+
+    def create(self,
+               full_name: str,
+               assets_dir: str,
+               output_schema_name: str,
+               *,
+               baseline_table_name: Optional[str] = None,
+               custom_metrics: Optional[List[MonitorCustomMetric]] = None,
+               data_classification_config: Optional[MonitorDataClassificationConfig] = None,
+               inference_log: Optional[MonitorInferenceLogProfileType] = None,
+               notifications: Optional[List[MonitorNotificationsConfig]] = None,
+               schedule: Optional[MonitorCronSchedule] = None,
+               skip_builtin_dashboard: Optional[bool] = None,
+               slicing_exprs: Optional[List[str]] = None,
+               snapshot: Optional[Any] = None,
+               time_series: Optional[MonitorTimeSeriesProfileType] = 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.
+        
+        Workspace assets, such as the dashboard, will be created in the workspace where this call was made.
+        
+        :param full_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:`MonitorCustomMetric`] (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:`MonitorInferenceLogProfileType` (optional)
+          Configuration for monitoring inference logs.
+        :param notifications: List[:class:`MonitorNotificationsConfig`] (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: Any (optional)
+          Configuration for monitoring snapshot tables.
+        :param time_series: :class:`MonitorTimeSeriesProfileType` (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'] = [v.as_dict() for v in notifications]
+        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
+        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', }
+        res = self._api.do('POST',
+                           f'/api/2.1/unity-catalog/tables/{full_name}/monitor',
+                           body=body,
+                           headers=headers)
+        return MonitorInfo.from_dict(res)
+
+    def delete(self, full_name: str):
+        """Delete a table monitor.
+        
+        Deletes 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.
+        
+        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 full_name: str
+          Full name of the table.
+        
+        
+        """
+
+        headers = {}
+        self._api.do('DELETE', f'/api/2.1/unity-catalog/tables/{full_name}/monitor', headers=headers)
+
+    def get(self, full_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.
+        
+        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
+          Full name of the table.
+        
+        :returns: :class:`MonitorInfo`
+        """
+
+        headers = {'Accept': 'application/json', }
+        res = self._api.do('GET', f'/api/2.1/unity-catalog/tables/{full_name}/monitor', headers=headers)
+        return MonitorInfo.from_dict(res)
+
+    def get_refresh(self, full_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.
+        
+        :param full_name: str
+          Full name of the table.
+        :param refresh_id: str
+          ID of the refresh.
+        
+        :returns: :class:`MonitorRefreshInfo`
+        """
+
+        headers = {'Accept': 'application/json', }
+        res = self._api.do('GET',
+                           f'/api/2.1/unity-catalog/tables/{full_name}/monitor/refreshes/{refresh_id}',
+                           headers=headers)
+        return MonitorRefreshInfo.from_dict(res)
+
+    def list_refreshes(self, full_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.
+        
+        :param full_name: str
+          Full name of the table.
+        
+        :returns: Iterator over :class:`MonitorRefreshInfo`
+        """
+
+        headers = {'Accept': 'application/json', }
+        res = self._api.do('GET',
+                           f'/api/2.1/unity-catalog/tables/{full_name}/monitor/refreshes',
+                           headers=headers)
+        return [MonitorRefreshInfo.from_dict(v) for v in res]
+
+    def run_refresh(self, full_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.
+        
+        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 full_name: str
+          Full name of the table.
+        
+        :returns: :class:`MonitorRefreshInfo`
+        """
+
+        headers = {'Accept': 'application/json', }
+        res = self._api.do('POST',
+                           f'/api/2.1/unity-catalog/tables/{full_name}/monitor/refreshes',
+                           headers=headers)
+        return MonitorRefreshInfo.from_dict(res)
+
+    def update(self,
+               full_name: str,
+               assets_dir: str,
+               output_schema_name: str,
+               *,
+               baseline_table_name: Optional[str] = None,
+               custom_metrics: Optional[List[MonitorCustomMetric]] = None,
+               data_classification_config: Optional[MonitorDataClassificationConfig] = None,
+               inference_log: Optional[MonitorInferenceLogProfileType] = None,
+               notifications: Optional[List[MonitorNotificationsConfig]] = None,
+               schedule: Optional[MonitorCronSchedule] = None,
+               slicing_exprs: Optional[List[str]] = None,
+               snapshot: Optional[Any] = None,
+               time_series: Optional[MonitorTimeSeriesProfileType] = 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.
+        
+        Certain configuration fields, such as output asset identifiers, cannot be updated.
+        
+        :param full_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:`MonitorCustomMetric`] (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:`MonitorInferenceLogProfileType` (optional)
+          Configuration for monitoring inference logs.
+        :param notifications: List[:class:`MonitorNotificationsConfig`] (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: Any (optional)
+          Configuration for monitoring snapshot tables.
+        :param time_series: :class:`MonitorTimeSeriesProfileType` (optional)
+          Configuration for monitoring time series tables.
+        
+        :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'] = [v.as_dict() for v in notifications]
+        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
+        if time_series is not None: body['time_series'] = time_series.as_dict()
+        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
+        res = self._api.do('PUT',
+                           f'/api/2.1/unity-catalog/tables/{full_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
@@ -5768,7 +6633,6 @@ class MetastoresAPI:
                delta_sharing_organization_name: Optional[str] = None,
                delta_sharing_recipient_token_lifetime_in_seconds: Optional[int] = None,
                delta_sharing_scope: Optional[UpdateMetastoreDeltaSharingScope] = None,
-               name: Optional[str] = None,
                new_name: Optional[str] = None,
                owner: Optional[str] = None,
                privilege_model_version: Optional[str] = None,
@@ -5787,8 +6651,6 @@ class MetastoresAPI:
           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 name: str (optional)
-          The user-specified name of the metastore.
         :param new_name: str (optional)
           New name for the metastore.
         :param owner: str (optional)
@@ -5807,7 +6669,6 @@ class MetastoresAPI:
             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 name is not None: body['name'] = name
         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
@@ -5970,10 +6831,9 @@ class ModelVersionsAPI:
                                 f'/api/2.1/unity-catalog/models/{full_name}/versions',
                                 query=query,
                                 headers=headers)
-            if 'model_versions' not in json or not json['model_versions']:
-                return
-            for v in json['model_versions']:
-                yield ModelVersionInfo.from_dict(v)
+            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']
@@ -6180,10 +7040,9 @@ class RegisteredModelsAPI:
 
         while True:
             json = self._api.do('GET', '/api/2.1/unity-catalog/models', query=query, headers=headers)
-            if 'registered_models' not in json or not json['registered_models']:
-                return
-            for v in json['registered_models']:
-                yield RegisteredModelInfo.from_dict(v)
+            if 'registered_models' in json:
+                for v in json['registered_models']:
+                    yield RegisteredModelInfo.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
             query['page_token'] = json['next_page_token']
@@ -6219,7 +7078,6 @@ class RegisteredModelsAPI:
                full_name: str,
                *,
                comment: Optional[str] = None,
-               name: Optional[str] = None,
                new_name: Optional[str] = None,
                owner: Optional[str] = None) -> RegisteredModelInfo:
         """Update a Registered Model.
@@ -6236,8 +7094,6 @@ class RegisteredModelsAPI:
           The three-level (fully qualified) name of the registered model
         :param comment: str (optional)
           The comment attached to the registered model
-        :param name: str (optional)
-          The name of the registered model
         :param new_name: str (optional)
           New name for the registered model.
         :param owner: str (optional)
@@ -6247,7 +7103,6 @@ class RegisteredModelsAPI:
         """
         body = {}
         if comment is not None: body['comment'] = comment
-        if name is not None: body['name'] = name
         if new_name is not None: body['new_name'] = new_name
         if owner is not None: body['owner'] = owner
         headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
@@ -6364,10 +7219,9 @@ class SchemasAPI:
 
         while True:
             json = self._api.do('GET', '/api/2.1/unity-catalog/schemas', query=query, headers=headers)
-            if 'schemas' not in json or not json['schemas']:
-                return
-            for v in json['schemas']:
-                yield SchemaInfo.from_dict(v)
+            if 'schemas' in json:
+                for v in json['schemas']:
+                    yield SchemaInfo.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
             query['page_token'] = json['next_page_token']
@@ -6377,7 +7231,6 @@ class SchemasAPI:
                *,
                comment: Optional[str] = None,
                enable_predictive_optimization: Optional[EnablePredictiveOptimization] = None,
-               name: Optional[str] = None,
                new_name: Optional[str] = None,
                owner: Optional[str] = None,
                properties: Optional[Dict[str, str]] = None) -> SchemaInfo:
@@ -6394,8 +7247,6 @@ class SchemasAPI:
           User-provided free-form text description.
         :param enable_predictive_optimization: :class:`EnablePredictiveOptimization` (optional)
           Whether predictive optimization should be enabled for this object and objects under it.
-        :param name: str (optional)
-          Name of schema, relative to parent catalog.
         :param new_name: str (optional)
           New name for the schema.
         :param owner: str (optional)
@@ -6409,7 +7260,6 @@ class SchemasAPI:
         if comment is not None: body['comment'] = comment
         if enable_predictive_optimization is not None:
             body['enable_predictive_optimization'] = enable_predictive_optimization.value
-        if name is not None: body['name'] = name
         if new_name is not None: body['new_name'] = new_name
         if owner is not None: body['owner'] = owner
         if properties is not None: body['properties'] = properties
@@ -6558,10 +7408,9 @@ class StorageCredentialsAPI:
                                 '/api/2.1/unity-catalog/storage-credentials',
                                 query=query,
                                 headers=headers)
-            if 'storage_credentials' not in json or not json['storage_credentials']:
-                return
-            for v in json['storage_credentials']:
-                yield StorageCredentialInfo.from_dict(v)
+            if 'storage_credentials' in json:
+                for v in json['storage_credentials']:
+                    yield StorageCredentialInfo.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
             query['page_token'] = json['next_page_token']
@@ -6868,13 +7717,34 @@ class TablesAPI:
         headers = {'Accept': 'application/json', }
         self._api.do('DELETE', f'/api/2.1/unity-catalog/tables/{full_name}', headers=headers)
 
+    def exists(self, full_name: str) -> TableExistsResponse:
+        """Get boolean reflecting if table exists.
+        
+        Gets if a table exists in the metastore for a specific catalog and schema. The caller must satisfy one
+        of the following requirements: * Be a metastore admin * Be the owner of the parent catalog * Be the
+        owner of the parent schema and have the USE_CATALOG privilege on the parent catalog * Have the
+        **USE_CATALOG** privilege on the parent catalog and the **USE_SCHEMA** privilege on the parent schema,
+        and either be the table owner or have the SELECT privilege on the table. * Have BROWSE privilege on
+        the parent catalog * Have BROWSE privilege on the parent schema.
+        
+        :param full_name: str
+          Full name of the table.
+        
+        :returns: :class:`TableExistsResponse`
+        """
+
+        headers = {'Accept': 'application/json', }
+        res = self._api.do('GET', f'/api/2.1/unity-catalog/tables/{full_name}/exists', headers=headers)
+        return TableExistsResponse.from_dict(res)
+
     def get(self, full_name: str, *, include_delta_metadata: Optional[bool] = None) -> TableInfo:
         """Get a table.
         
-        Gets a table from the metastore for a specific catalog and schema. The caller must be a metastore
-        admin, be the owner of the table and have the **USE_CATALOG** privilege on the parent catalog and the
-        **USE_SCHEMA** privilege on the parent schema, or be the owner of the table and have the **SELECT**
-        privilege on it as well.
+        Gets a table from the metastore for a specific catalog and schema. The caller must satisfy one of the
+        following requirements: * Be a metastore admin * Be the owner of the parent catalog * Be the owner of
+        the parent schema and have the USE_CATALOG privilege on the parent catalog * Have the **USE_CATALOG**
+        privilege on the parent catalog and the **USE_SCHEMA** privilege on the parent schema, and either be
+        the table owner or have the SELECT privilege on the table.
         
         :param full_name: str
           Full name of the table.
@@ -6940,10 +7810,9 @@ class TablesAPI:
 
         while True:
             json = self._api.do('GET', '/api/2.1/unity-catalog/tables', query=query, headers=headers)
-            if 'tables' not in json or not json['tables']:
-                return
-            for v in json['tables']:
-                yield TableInfo.from_dict(v)
+            if 'tables' in json:
+                for v in json['tables']:
+                    yield TableInfo.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
             query['page_token'] = json['next_page_token']
@@ -6996,10 +7865,9 @@ class TablesAPI:
 
         while True:
             json = self._api.do('GET', '/api/2.1/unity-catalog/table-summaries', query=query, headers=headers)
-            if 'tables' not in json or not json['tables']:
-                return
-            for v in json['tables']:
-                yield TableSummary.from_dict(v)
+            if 'tables' in json:
+                for v in json['tables']:
+                    yield TableSummary.from_dict(v)
             if 'next_page_token' not in json or not json['next_page_token']:
                 return
             query['page_token'] = json['next_page_token']
@@ -7156,7 +8024,6 @@ class VolumesAPI:
                full_name_arg: str,
                *,
                comment: Optional[str] = None,
-               name: Optional[str] = None,
                new_name: Optional[str] = None,
                owner: Optional[str] = None) -> VolumeInfo:
         """Update a Volume.
@@ -7173,8 +8040,6 @@ class VolumesAPI:
           The three-level (fully qualified) name of the volume
         :param comment: str (optional)
           The comment attached to the volume
-        :param name: str (optional)
-          The name of the volume
         :param new_name: str (optional)
           New name for the volume.
         :param owner: str (optional)
@@ -7184,7 +8049,6 @@ class VolumesAPI:
         """
         body = {}
         if comment is not None: body['comment'] = comment
-        if name is not None: body['name'] = name
         if new_name is not None: body['new_name'] = new_name
         if owner is not None: body['owner'] = owner
         headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }