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

databricks/sdk/service/sql.py

@@ -46,69 +46,206 @@ class AccessControl:
 
 @dataclass
 class Alert:
-    created_at: Optional[str] = None
-    """Timestamp when the alert was created."""
+    condition: Optional[AlertCondition] = None
+    """Trigger conditions of the alert."""
 
-    id: Optional[str] = None
-    """Alert ID."""
+    create_time: Optional[str] = None
+    """The timestamp indicating when the alert was created."""
 
-    last_triggered_at: Optional[str] = None
-    """Timestamp when the alert was last triggered."""
+    custom_body: Optional[str] = None
+    """Custom body of alert notification, if it exists. See [here] for custom templating instructions.
+    
+    [here]: https://docs.databricks.com/sql/user/alerts/index.html"""
 
-    name: Optional[str] = None
-    """Name of the alert."""
+    custom_subject: Optional[str] = None
+    """Custom subject of alert notification, if it exists. This can include email subject entries and
+    Slack notification headers, for example. See [here] for custom templating instructions.
+    
+    [here]: https://docs.databricks.com/sql/user/alerts/index.html"""
 
-    options: Optional[AlertOptions] = None
-    """Alert configuration options."""
+    display_name: Optional[str] = None
+    """The display name of the alert."""
 
-    parent: Optional[str] = None
-    """The identifier of the workspace folder containing the object."""
+    id: Optional[str] = None
+    """UUID identifying the alert."""
 
-    query: Optional[AlertQuery] = None
+    lifecycle_state: Optional[LifecycleState] = None
+    """The workspace state of the alert. Used for tracking trashed status."""
 
-    rearm: Optional[int] = None
-    """Number of seconds after being triggered before the alert rearms itself and can be triggered
-    again. If `null`, alert will never be triggered again."""
+    owner_user_name: Optional[str] = None
+    """The owner's username. This field is set to "Unavailable" if the user has been deleted."""
+
+    parent_path: Optional[str] = None
+    """The workspace path of the folder containing the alert."""
+
+    query_id: Optional[str] = None
+    """UUID of the query attached to the alert."""
+
+    seconds_to_retrigger: Optional[int] = None
+    """Number of seconds an alert must wait after being triggered to rearm itself. After rearming, it
+    can be triggered again. If 0 or not specified, the alert will not be triggered again."""
 
     state: Optional[AlertState] = None
-    """State of the alert. Possible values are: `unknown` (yet to be evaluated), `triggered` (evaluated
-    and fulfilled trigger conditions), or `ok` (evaluated and did not fulfill trigger conditions)."""
+    """Current state of the alert's trigger status. This field is set to UNKNOWN if the alert has not
+    yet been evaluated or ran into an error during the last evaluation."""
 
-    updated_at: Optional[str] = None
-    """Timestamp when the alert was last updated."""
+    trigger_time: Optional[str] = None
+    """Timestamp when the alert was last triggered, if the alert has been triggered before."""
 
-    user: Optional[User] = None
+    update_time: Optional[str] = None
+    """The timestamp indicating when the alert was updated."""
 
     def as_dict(self) -> dict:
         """Serializes the Alert into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.condition: body['condition'] = self.condition.as_dict()
+        if self.create_time is not None: body['create_time'] = self.create_time
+        if self.custom_body is not None: body['custom_body'] = self.custom_body
+        if self.custom_subject is not None: body['custom_subject'] = self.custom_subject
+        if self.display_name is not None: body['display_name'] = self.display_name
         if self.id is not None: body['id'] = self.id
-        if self.last_triggered_at is not None: body['last_triggered_at'] = self.last_triggered_at
-        if self.name is not None: body['name'] = self.name
-        if self.options: body['options'] = self.options.as_dict()
-        if self.parent is not None: body['parent'] = self.parent
-        if self.query: body['query'] = self.query.as_dict()
-        if self.rearm is not None: body['rearm'] = self.rearm
+        if self.lifecycle_state is not None: body['lifecycle_state'] = self.lifecycle_state.value
+        if self.owner_user_name is not None: body['owner_user_name'] = self.owner_user_name
+        if self.parent_path is not None: body['parent_path'] = self.parent_path
+        if self.query_id is not None: body['query_id'] = self.query_id
+        if self.seconds_to_retrigger is not None: body['seconds_to_retrigger'] = self.seconds_to_retrigger
         if self.state is not None: body['state'] = self.state.value
-        if self.updated_at is not None: body['updated_at'] = self.updated_at
-        if self.user: body['user'] = self.user.as_dict()
+        if self.trigger_time is not None: body['trigger_time'] = self.trigger_time
+        if self.update_time is not None: body['update_time'] = self.update_time
         return body
 
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> Alert:
         """Deserializes the Alert from a dictionary."""
-        return cls(created_at=d.get('created_at', None),
+        return cls(condition=_from_dict(d, 'condition', AlertCondition),
+                   create_time=d.get('create_time', None),
+                   custom_body=d.get('custom_body', None),
+                   custom_subject=d.get('custom_subject', None),
+                   display_name=d.get('display_name', None),
                    id=d.get('id', None),
-                   last_triggered_at=d.get('last_triggered_at', None),
-                   name=d.get('name', None),
-                   options=_from_dict(d, 'options', AlertOptions),
-                   parent=d.get('parent', None),
-                   query=_from_dict(d, 'query', AlertQuery),
-                   rearm=d.get('rearm', None),
+                   lifecycle_state=_enum(d, 'lifecycle_state', LifecycleState),
+                   owner_user_name=d.get('owner_user_name', None),
+                   parent_path=d.get('parent_path', None),
+                   query_id=d.get('query_id', None),
+                   seconds_to_retrigger=d.get('seconds_to_retrigger', None),
                    state=_enum(d, 'state', AlertState),
-                   updated_at=d.get('updated_at', None),
-                   user=_from_dict(d, 'user', User))
+                   trigger_time=d.get('trigger_time', None),
+                   update_time=d.get('update_time', None))
+
+
+@dataclass
+class AlertCondition:
+    empty_result_state: Optional[AlertState] = None
+    """Alert state if result is empty."""
+
+    op: Optional[AlertOperator] = None
+    """Operator used for comparison in alert evaluation."""
+
+    operand: Optional[AlertConditionOperand] = None
+    """Name of the column from the query result to use for comparison in alert evaluation."""
+
+    threshold: Optional[AlertConditionThreshold] = None
+    """Threshold value used for comparison in alert evaluation."""
+
+    def as_dict(self) -> dict:
+        """Serializes the AlertCondition into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.empty_result_state is not None: body['empty_result_state'] = self.empty_result_state.value
+        if self.op is not None: body['op'] = self.op.value
+        if self.operand: body['operand'] = self.operand.as_dict()
+        if self.threshold: body['threshold'] = self.threshold.as_dict()
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> AlertCondition:
+        """Deserializes the AlertCondition from a dictionary."""
+        return cls(empty_result_state=_enum(d, 'empty_result_state', AlertState),
+                   op=_enum(d, 'op', AlertOperator),
+                   operand=_from_dict(d, 'operand', AlertConditionOperand),
+                   threshold=_from_dict(d, 'threshold', AlertConditionThreshold))
+
+
+@dataclass
+class AlertConditionOperand:
+    column: Optional[AlertOperandColumn] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the AlertConditionOperand into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.column: body['column'] = self.column.as_dict()
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> AlertConditionOperand:
+        """Deserializes the AlertConditionOperand from a dictionary."""
+        return cls(column=_from_dict(d, 'column', AlertOperandColumn))
+
+
+@dataclass
+class AlertConditionThreshold:
+    value: Optional[AlertOperandValue] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the AlertConditionThreshold into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.value: body['value'] = self.value.as_dict()
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> AlertConditionThreshold:
+        """Deserializes the AlertConditionThreshold from a dictionary."""
+        return cls(value=_from_dict(d, 'value', AlertOperandValue))
+
+
+@dataclass
+class AlertOperandColumn:
+    name: Optional[str] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the AlertOperandColumn into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.name is not None: body['name'] = self.name
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> AlertOperandColumn:
+        """Deserializes the AlertOperandColumn from a dictionary."""
+        return cls(name=d.get('name', None))
+
+
+@dataclass
+class AlertOperandValue:
+    bool_value: Optional[bool] = None
+
+    double_value: Optional[float] = None
+
+    string_value: Optional[str] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the AlertOperandValue into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.bool_value is not None: body['bool_value'] = self.bool_value
+        if self.double_value is not None: body['double_value'] = self.double_value
+        if self.string_value is not None: body['string_value'] = self.string_value
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> AlertOperandValue:
+        """Deserializes the AlertOperandValue from a dictionary."""
+        return cls(bool_value=d.get('bool_value', None),
+                   double_value=d.get('double_value', None),
+                   string_value=d.get('string_value', None))
+
+
+class AlertOperator(Enum):
+
+    EQUAL = 'EQUAL'
+    GREATER_THAN = 'GREATER_THAN'
+    GREATER_THAN_OR_EQUAL = 'GREATER_THAN_OR_EQUAL'
+    IS_NULL = 'IS_NULL'
+    LESS_THAN = 'LESS_THAN'
+    LESS_THAN_OR_EQUAL = 'LESS_THAN_OR_EQUAL'
+    NOT_EQUAL = 'NOT_EQUAL'
 
 
 @dataclass
@@ -182,7 +319,7 @@ class AlertQuery:
 
     data_source_id: Optional[str] = None
     """Data source ID maps to the ID of the data source used by the resource and is distinct from the
-    warehouse ID. [Learn more].
+    warehouse ID. [Learn more]
     
     [Learn more]: https://docs.databricks.com/api/workspace/datasources/list"""
 
@@ -259,12 +396,10 @@ class AlertQuery:
 
 
 class AlertState(Enum):
-    """State of the alert. Possible values are: `unknown` (yet to be evaluated), `triggered` (evaluated
-    and fulfilled trigger conditions), or `ok` (evaluated and did not fulfill trigger conditions)."""
 
-    OK = 'ok'
-    TRIGGERED = 'triggered'
-    UNKNOWN = 'unknown'
+    OK = 'OK'
+    TRIGGERED = 'TRIGGERED'
+    UNKNOWN = 'UNKNOWN'
 
 
 @dataclass
@@ -338,10 +473,10 @@ class Channel:
 
 @dataclass
 class ChannelInfo:
-    """Channel information for the SQL warehouse at the time of query execution"""
+    """Details about a Channel."""
 
     dbsql_version: Optional[str] = None
-    """DBSQL Version the channel is mapped to"""
+    """DB SQL Version the Channel is mapped to."""
 
     name: Optional[ChannelName] = None
     """Name of the channel"""
@@ -368,6 +503,29 @@ class ChannelName(Enum):
     CHANNEL_NAME_UNSPECIFIED = 'CHANNEL_NAME_UNSPECIFIED'
 
 
+@dataclass
+class ClientCallContext:
+    """Client code that triggered the request"""
+
+    file_name: Optional[EncodedText] = None
+    """File name that contains the last line that triggered the request."""
+
+    line_number: Optional[int] = None
+    """Last line number within a file or notebook cell that triggered the request."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ClientCallContext into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.file_name: body['file_name'] = self.file_name.as_dict()
+        if self.line_number is not None: body['line_number'] = self.line_number
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> ClientCallContext:
+        """Deserializes the ClientCallContext from a dictionary."""
+        return cls(file_name=_from_dict(d, 'file_name', EncodedText), line_number=d.get('line_number', None))
+
+
 @dataclass
 class ColumnInfo:
     name: Optional[str] = None
@@ -442,6 +600,68 @@ class ColumnInfoTypeName(Enum):
     USER_DEFINED_TYPE = 'USER_DEFINED_TYPE'
 
 
+@dataclass
+class ContextFilter:
+    dbsql_alert_id: Optional[str] = None
+    """Databricks SQL Alert id"""
+
+    dbsql_dashboard_id: Optional[str] = None
+    """Databricks SQL Dashboard id"""
+
+    dbsql_query_id: Optional[str] = None
+    """Databricks SQL Query id"""
+
+    dbsql_session_id: Optional[str] = None
+    """Databricks SQL Query session id"""
+
+    job_id: Optional[str] = None
+    """Databricks Workflows id"""
+
+    job_run_id: Optional[str] = None
+    """Databricks Workflows task run id"""
+
+    lakeview_dashboard_id: Optional[str] = None
+    """Databricks Lakeview Dashboard id"""
+
+    notebook_cell_run_id: Optional[str] = None
+    """Databricks Notebook runnableCommandId"""
+
+    notebook_id: Optional[str] = None
+    """Databricks Notebook id"""
+
+    statement_ids: Optional[List[str]] = None
+    """Databricks Query History statement ids."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ContextFilter into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.dbsql_alert_id is not None: body['dbsql_alert_id'] = self.dbsql_alert_id
+        if self.dbsql_dashboard_id is not None: body['dbsql_dashboard_id'] = self.dbsql_dashboard_id
+        if self.dbsql_query_id is not None: body['dbsql_query_id'] = self.dbsql_query_id
+        if self.dbsql_session_id is not None: body['dbsql_session_id'] = self.dbsql_session_id
+        if self.job_id is not None: body['job_id'] = self.job_id
+        if self.job_run_id is not None: body['job_run_id'] = self.job_run_id
+        if self.lakeview_dashboard_id is not None: body['lakeview_dashboard_id'] = self.lakeview_dashboard_id
+        if self.notebook_cell_run_id is not None: body['notebook_cell_run_id'] = self.notebook_cell_run_id
+        if self.notebook_id is not None: body['notebook_id'] = self.notebook_id
+        if self.statement_ids: body['statement_ids'] = [v for v in self.statement_ids]
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> ContextFilter:
+        """Deserializes the ContextFilter from a dictionary."""
+        return cls(dbsql_alert_id=d.get('dbsql_alert_id', None),
+                   dbsql_dashboard_id=d.get('dbsql_dashboard_id', None),
+                   dbsql_query_id=d.get('dbsql_query_id', None),
+                   dbsql_session_id=d.get('dbsql_session_id', None),
+                   job_id=d.get('job_id', None),
+                   job_run_id=d.get('job_run_id', None),
+                   lakeview_dashboard_id=d.get('lakeview_dashboard_id', None),
+                   notebook_cell_run_id=d.get('notebook_cell_run_id', None),
+                   notebook_id=d.get('notebook_id', None),
+                   statement_ids=d.get('statement_ids', None))
+
+
 @dataclass
 class CreateAlert:
     name: str
@@ -481,99 +701,305 @@ class CreateAlert:
 
 
 @dataclass
-class CreateWarehouseRequest:
-    auto_stop_mins: Optional[int] = None
-    """The amount of time in minutes that a SQL warehouse must be idle (i.e., no RUNNING queries)
-    before it is automatically stopped.
-    
-    Supported values: - Must be == 0 or >= 10 mins - 0 indicates no autostop.
-    
-    Defaults to 120 mins"""
+class CreateAlertRequest:
+    alert: Optional[CreateAlertRequestAlert] = None
 
-    channel: Optional[Channel] = None
-    """Channel Details"""
+    def as_dict(self) -> dict:
+        """Serializes the CreateAlertRequest into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.alert: body['alert'] = self.alert.as_dict()
+        return body
 
-    cluster_size: Optional[str] = None
-    """Size of the clusters allocated for this warehouse. Increasing the size of a spark cluster allows
-    you to run larger queries on it. If you want to increase the number of concurrent queries,
-    please tune max_num_clusters.
-    
-    Supported values: - 2X-Small - X-Small - Small - Medium - Large - X-Large - 2X-Large - 3X-Large
-    - 4X-Large"""
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> CreateAlertRequest:
+        """Deserializes the CreateAlertRequest from a dictionary."""
+        return cls(alert=_from_dict(d, 'alert', CreateAlertRequestAlert))
 
-    creator_name: Optional[str] = None
-    """warehouse creator name"""
 
-    enable_photon: Optional[bool] = None
-    """Configures whether the warehouse should use Photon optimized clusters.
+@dataclass
+class CreateAlertRequestAlert:
+    condition: Optional[AlertCondition] = None
+    """Trigger conditions of the alert."""
+
+    custom_body: Optional[str] = None
+    """Custom body of alert notification, if it exists. See [here] for custom templating instructions.
     
-    Defaults to false."""
+    [here]: https://docs.databricks.com/sql/user/alerts/index.html"""
 
-    enable_serverless_compute: Optional[bool] = None
-    """Configures whether the warehouse should use serverless compute"""
+    custom_subject: Optional[str] = None
+    """Custom subject of alert notification, if it exists. This can include email subject entries and
+    Slack notification headers, for example. See [here] for custom templating instructions.
+    
+    [here]: https://docs.databricks.com/sql/user/alerts/index.html"""
 
-    instance_profile_arn: Optional[str] = None
-    """Deprecated. Instance profile used to pass IAM role to the cluster"""
+    display_name: Optional[str] = None
+    """The display name of the alert."""
 
-    max_num_clusters: Optional[int] = None
-    """Maximum number of clusters that the autoscaler will create to handle concurrent queries.
-    
-    Supported values: - Must be >= min_num_clusters - Must be <= 30.
-    
-    Defaults to min_clusters if unset."""
+    parent_path: Optional[str] = None
+    """The workspace path of the folder containing the alert."""
 
-    min_num_clusters: Optional[int] = None
-    """Minimum number of available clusters that will be maintained for this SQL warehouse. Increasing
-    this will ensure that a larger number of clusters are always running and therefore may reduce
-    the cold start time for new queries. This is similar to reserved vs. revocable cores in a
-    resource manager.
-    
-    Supported values: - Must be > 0 - Must be <= min(max_num_clusters, 30)
-    
-    Defaults to 1"""
+    query_id: Optional[str] = None
+    """UUID of the query attached to the alert."""
 
-    name: Optional[str] = None
-    """Logical name for the cluster.
-    
-    Supported values: - Must be unique within an org. - Must be less than 100 characters."""
+    seconds_to_retrigger: Optional[int] = None
+    """Number of seconds an alert must wait after being triggered to rearm itself. After rearming, it
+    can be triggered again. If 0 or not specified, the alert will not be triggered again."""
 
-    spot_instance_policy: Optional[SpotInstancePolicy] = None
-    """Configurations whether the warehouse should use spot instances."""
+    def as_dict(self) -> dict:
+        """Serializes the CreateAlertRequestAlert into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.condition: body['condition'] = self.condition.as_dict()
+        if self.custom_body is not None: body['custom_body'] = self.custom_body
+        if self.custom_subject is not None: body['custom_subject'] = self.custom_subject
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.parent_path is not None: body['parent_path'] = self.parent_path
+        if self.query_id is not None: body['query_id'] = self.query_id
+        if self.seconds_to_retrigger is not None: body['seconds_to_retrigger'] = self.seconds_to_retrigger
+        return body
 
-    tags: Optional[EndpointTags] = None
-    """A set of key-value pairs that will be tagged on all resources (e.g., AWS instances and EBS
-    volumes) associated with this SQL warehouse.
-    
-    Supported values: - Number of tags < 45."""
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> CreateAlertRequestAlert:
+        """Deserializes the CreateAlertRequestAlert from a dictionary."""
+        return cls(condition=_from_dict(d, 'condition', AlertCondition),
+                   custom_body=d.get('custom_body', None),
+                   custom_subject=d.get('custom_subject', None),
+                   display_name=d.get('display_name', None),
+                   parent_path=d.get('parent_path', None),
+                   query_id=d.get('query_id', None),
+                   seconds_to_retrigger=d.get('seconds_to_retrigger', None))
 
-    warehouse_type: Optional[CreateWarehouseRequestWarehouseType] = None
-    """Warehouse type: `PRO` or `CLASSIC`. If you want to use serverless compute, you must set to `PRO`
-    and also set the field `enable_serverless_compute` to `true`."""
+
+@dataclass
+class CreateQueryRequest:
+    query: Optional[CreateQueryRequestQuery] = None
 
     def as_dict(self) -> dict:
-        """Serializes the CreateWarehouseRequest into a dictionary suitable for use as a JSON request body."""
+        """Serializes the CreateQueryRequest into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.auto_stop_mins is not None: body['auto_stop_mins'] = self.auto_stop_mins
-        if self.channel: body['channel'] = self.channel.as_dict()
-        if self.cluster_size is not None: body['cluster_size'] = self.cluster_size
-        if self.creator_name is not None: body['creator_name'] = self.creator_name
-        if self.enable_photon is not None: body['enable_photon'] = self.enable_photon
-        if self.enable_serverless_compute is not None:
-            body['enable_serverless_compute'] = self.enable_serverless_compute
-        if self.instance_profile_arn is not None: body['instance_profile_arn'] = self.instance_profile_arn
-        if self.max_num_clusters is not None: body['max_num_clusters'] = self.max_num_clusters
-        if self.min_num_clusters is not None: body['min_num_clusters'] = self.min_num_clusters
-        if self.name is not None: body['name'] = self.name
-        if self.spot_instance_policy is not None:
-            body['spot_instance_policy'] = self.spot_instance_policy.value
-        if self.tags: body['tags'] = self.tags.as_dict()
-        if self.warehouse_type is not None: body['warehouse_type'] = self.warehouse_type.value
+        if self.query: body['query'] = self.query.as_dict()
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CreateWarehouseRequest:
-        """Deserializes the CreateWarehouseRequest from a dictionary."""
-        return cls(auto_stop_mins=d.get('auto_stop_mins', None),
+    def from_dict(cls, d: Dict[str, any]) -> CreateQueryRequest:
+        """Deserializes the CreateQueryRequest from a dictionary."""
+        return cls(query=_from_dict(d, 'query', CreateQueryRequestQuery))
+
+
+@dataclass
+class CreateQueryRequestQuery:
+    apply_auto_limit: Optional[bool] = None
+    """Whether to apply a 1000 row limit to the query result."""
+
+    catalog: Optional[str] = None
+    """Name of the catalog where this query will be executed."""
+
+    description: Optional[str] = None
+    """General description that conveys additional information about this query such as usage notes."""
+
+    display_name: Optional[str] = None
+    """Display name of the query that appears in list views, widget headings, and on the query page."""
+
+    parameters: Optional[List[QueryParameter]] = None
+    """List of query parameter definitions."""
+
+    parent_path: Optional[str] = None
+    """Workspace path of the workspace folder containing the object."""
+
+    query_text: Optional[str] = None
+    """Text of the query to be run."""
+
+    run_as_mode: Optional[RunAsMode] = None
+    """Sets the "Run as" role for the object."""
+
+    schema: Optional[str] = None
+    """Name of the schema where this query will be executed."""
+
+    tags: Optional[List[str]] = None
+
+    warehouse_id: Optional[str] = None
+    """ID of the SQL warehouse attached to the query."""
+
+    def as_dict(self) -> dict:
+        """Serializes the CreateQueryRequestQuery into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.apply_auto_limit is not None: body['apply_auto_limit'] = self.apply_auto_limit
+        if self.catalog is not None: body['catalog'] = self.catalog
+        if self.description is not None: body['description'] = self.description
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.parameters: body['parameters'] = [v.as_dict() for v in self.parameters]
+        if self.parent_path is not None: body['parent_path'] = self.parent_path
+        if self.query_text is not None: body['query_text'] = self.query_text
+        if self.run_as_mode is not None: body['run_as_mode'] = self.run_as_mode.value
+        if self.schema is not None: body['schema'] = self.schema
+        if self.tags: body['tags'] = [v for v in self.tags]
+        if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> CreateQueryRequestQuery:
+        """Deserializes the CreateQueryRequestQuery from a dictionary."""
+        return cls(apply_auto_limit=d.get('apply_auto_limit', None),
+                   catalog=d.get('catalog', None),
+                   description=d.get('description', None),
+                   display_name=d.get('display_name', None),
+                   parameters=_repeated_dict(d, 'parameters', QueryParameter),
+                   parent_path=d.get('parent_path', None),
+                   query_text=d.get('query_text', None),
+                   run_as_mode=_enum(d, 'run_as_mode', RunAsMode),
+                   schema=d.get('schema', None),
+                   tags=d.get('tags', None),
+                   warehouse_id=d.get('warehouse_id', None))
+
+
+@dataclass
+class CreateVisualizationRequest:
+    visualization: Optional[CreateVisualizationRequestVisualization] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the CreateVisualizationRequest into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.visualization: body['visualization'] = self.visualization.as_dict()
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> CreateVisualizationRequest:
+        """Deserializes the CreateVisualizationRequest from a dictionary."""
+        return cls(visualization=_from_dict(d, 'visualization', CreateVisualizationRequestVisualization))
+
+
+@dataclass
+class CreateVisualizationRequestVisualization:
+    display_name: Optional[str] = None
+    """The display name of the visualization."""
+
+    query_id: Optional[str] = None
+    """UUID of the query that the visualization is attached to."""
+
+    serialized_options: Optional[str] = None
+    """The visualization options varies widely from one visualization type to the next and is
+    unsupported. Databricks does not recommend modifying visualization options directly."""
+
+    serialized_query_plan: Optional[str] = None
+    """The visualization query plan varies widely from one visualization type to the next and is
+    unsupported. Databricks does not recommend modifying the visualization query plan directly."""
+
+    type: Optional[str] = None
+    """The type of visualization: counter, table, funnel, and so on."""
+
+    def as_dict(self) -> dict:
+        """Serializes the CreateVisualizationRequestVisualization into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.query_id is not None: body['query_id'] = self.query_id
+        if self.serialized_options is not None: body['serialized_options'] = self.serialized_options
+        if self.serialized_query_plan is not None: body['serialized_query_plan'] = self.serialized_query_plan
+        if self.type is not None: body['type'] = self.type
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> CreateVisualizationRequestVisualization:
+        """Deserializes the CreateVisualizationRequestVisualization from a dictionary."""
+        return cls(display_name=d.get('display_name', None),
+                   query_id=d.get('query_id', None),
+                   serialized_options=d.get('serialized_options', None),
+                   serialized_query_plan=d.get('serialized_query_plan', None),
+                   type=d.get('type', None))
+
+
+@dataclass
+class CreateWarehouseRequest:
+    auto_stop_mins: Optional[int] = None
+    """The amount of time in minutes that a SQL warehouse must be idle (i.e., no RUNNING queries)
+    before it is automatically stopped.
+    
+    Supported values: - Must be == 0 or >= 10 mins - 0 indicates no autostop.
+    
+    Defaults to 120 mins"""
+
+    channel: Optional[Channel] = None
+    """Channel Details"""
+
+    cluster_size: Optional[str] = None
+    """Size of the clusters allocated for this warehouse. Increasing the size of a spark cluster allows
+    you to run larger queries on it. If you want to increase the number of concurrent queries,
+    please tune max_num_clusters.
+    
+    Supported values: - 2X-Small - X-Small - Small - Medium - Large - X-Large - 2X-Large - 3X-Large
+    - 4X-Large"""
+
+    creator_name: Optional[str] = None
+    """warehouse creator name"""
+
+    enable_photon: Optional[bool] = None
+    """Configures whether the warehouse should use Photon optimized clusters.
+    
+    Defaults to false."""
+
+    enable_serverless_compute: Optional[bool] = None
+    """Configures whether the warehouse should use serverless compute"""
+
+    instance_profile_arn: Optional[str] = None
+    """Deprecated. Instance profile used to pass IAM role to the cluster"""
+
+    max_num_clusters: Optional[int] = None
+    """Maximum number of clusters that the autoscaler will create to handle concurrent queries.
+    
+    Supported values: - Must be >= min_num_clusters - Must be <= 30.
+    
+    Defaults to min_clusters if unset."""
+
+    min_num_clusters: Optional[int] = None
+    """Minimum number of available clusters that will be maintained for this SQL warehouse. Increasing
+    this will ensure that a larger number of clusters are always running and therefore may reduce
+    the cold start time for new queries. This is similar to reserved vs. revocable cores in a
+    resource manager.
+    
+    Supported values: - Must be > 0 - Must be <= min(max_num_clusters, 30)
+    
+    Defaults to 1"""
+
+    name: Optional[str] = None
+    """Logical name for the cluster.
+    
+    Supported values: - Must be unique within an org. - Must be less than 100 characters."""
+
+    spot_instance_policy: Optional[SpotInstancePolicy] = None
+    """Configurations whether the warehouse should use spot instances."""
+
+    tags: Optional[EndpointTags] = None
+    """A set of key-value pairs that will be tagged on all resources (e.g., AWS instances and EBS
+    volumes) associated with this SQL warehouse.
+    
+    Supported values: - Number of tags < 45."""
+
+    warehouse_type: Optional[CreateWarehouseRequestWarehouseType] = None
+    """Warehouse type: `PRO` or `CLASSIC`. If you want to use serverless compute, you must set to `PRO`
+    and also set the field `enable_serverless_compute` to `true`."""
+
+    def as_dict(self) -> dict:
+        """Serializes the CreateWarehouseRequest into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.auto_stop_mins is not None: body['auto_stop_mins'] = self.auto_stop_mins
+        if self.channel: body['channel'] = self.channel.as_dict()
+        if self.cluster_size is not None: body['cluster_size'] = self.cluster_size
+        if self.creator_name is not None: body['creator_name'] = self.creator_name
+        if self.enable_photon is not None: body['enable_photon'] = self.enable_photon
+        if self.enable_serverless_compute is not None:
+            body['enable_serverless_compute'] = self.enable_serverless_compute
+        if self.instance_profile_arn is not None: body['instance_profile_arn'] = self.instance_profile_arn
+        if self.max_num_clusters is not None: body['max_num_clusters'] = self.max_num_clusters
+        if self.min_num_clusters is not None: body['min_num_clusters'] = self.min_num_clusters
+        if self.name is not None: body['name'] = self.name
+        if self.spot_instance_policy is not None:
+            body['spot_instance_policy'] = self.spot_instance_policy.value
+        if self.tags: body['tags'] = self.tags.as_dict()
+        if self.warehouse_type is not None: body['warehouse_type'] = self.warehouse_type.value
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> CreateWarehouseRequest:
+        """Deserializes the CreateWarehouseRequest from a dictionary."""
+        return cls(auto_stop_mins=d.get('auto_stop_mins', None),
                    channel=_from_dict(d, 'channel', Channel),
                    cluster_size=d.get('cluster_size', None),
                    creator_name=d.get('creator_name', None),
@@ -856,7 +1282,7 @@ class DataSource:
 
     id: Optional[str] = None
     """Data source ID maps to the ID of the data source used by the resource and is distinct from the
-    warehouse ID. [Learn more].
+    warehouse ID. [Learn more]
     
     [Learn more]: https://docs.databricks.com/api/workspace/datasources/list"""
 
@@ -913,6 +1339,121 @@ class DataSource:
                    warehouse_id=d.get('warehouse_id', None))
 
 
+class DatePrecision(Enum):
+
+    DAY_PRECISION = 'DAY_PRECISION'
+    MINUTE_PRECISION = 'MINUTE_PRECISION'
+    SECOND_PRECISION = 'SECOND_PRECISION'
+
+
+@dataclass
+class DateRange:
+    start: str
+
+    end: str
+
+    def as_dict(self) -> dict:
+        """Serializes the DateRange into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.end is not None: body['end'] = self.end
+        if self.start is not None: body['start'] = self.start
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> DateRange:
+        """Deserializes the DateRange from a dictionary."""
+        return cls(end=d.get('end', None), start=d.get('start', None))
+
+
+@dataclass
+class DateRangeValue:
+    date_range_value: Optional[DateRange] = None
+    """Manually specified date-time range value."""
+
+    dynamic_date_range_value: Optional[DateRangeValueDynamicDateRange] = None
+    """Dynamic date-time range value based on current date-time."""
+
+    precision: Optional[DatePrecision] = None
+    """Date-time precision to format the value into when the query is run. Defaults to DAY_PRECISION
+    (YYYY-MM-DD)."""
+
+    start_day_of_week: Optional[int] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the DateRangeValue into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.date_range_value: body['date_range_value'] = self.date_range_value.as_dict()
+        if self.dynamic_date_range_value is not None:
+            body['dynamic_date_range_value'] = self.dynamic_date_range_value.value
+        if self.precision is not None: body['precision'] = self.precision.value
+        if self.start_day_of_week is not None: body['start_day_of_week'] = self.start_day_of_week
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> DateRangeValue:
+        """Deserializes the DateRangeValue from a dictionary."""
+        return cls(date_range_value=_from_dict(d, 'date_range_value', DateRange),
+                   dynamic_date_range_value=_enum(d, 'dynamic_date_range_value',
+                                                  DateRangeValueDynamicDateRange),
+                   precision=_enum(d, 'precision', DatePrecision),
+                   start_day_of_week=d.get('start_day_of_week', None))
+
+
+class DateRangeValueDynamicDateRange(Enum):
+
+    LAST_12_MONTHS = 'LAST_12_MONTHS'
+    LAST_14_DAYS = 'LAST_14_DAYS'
+    LAST_24_HOURS = 'LAST_24_HOURS'
+    LAST_30_DAYS = 'LAST_30_DAYS'
+    LAST_60_DAYS = 'LAST_60_DAYS'
+    LAST_7_DAYS = 'LAST_7_DAYS'
+    LAST_8_HOURS = 'LAST_8_HOURS'
+    LAST_90_DAYS = 'LAST_90_DAYS'
+    LAST_HOUR = 'LAST_HOUR'
+    LAST_MONTH = 'LAST_MONTH'
+    LAST_WEEK = 'LAST_WEEK'
+    LAST_YEAR = 'LAST_YEAR'
+    THIS_MONTH = 'THIS_MONTH'
+    THIS_WEEK = 'THIS_WEEK'
+    THIS_YEAR = 'THIS_YEAR'
+    TODAY = 'TODAY'
+    YESTERDAY = 'YESTERDAY'
+
+
+@dataclass
+class DateValue:
+    date_value: Optional[str] = None
+    """Manually specified date-time value."""
+
+    dynamic_date_value: Optional[DateValueDynamicDate] = None
+    """Dynamic date-time value based on current date-time."""
+
+    precision: Optional[DatePrecision] = None
+    """Date-time precision to format the value into when the query is run. Defaults to DAY_PRECISION
+    (YYYY-MM-DD)."""
+
+    def as_dict(self) -> dict:
+        """Serializes the DateValue into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.date_value is not None: body['date_value'] = self.date_value
+        if self.dynamic_date_value is not None: body['dynamic_date_value'] = self.dynamic_date_value.value
+        if self.precision is not None: body['precision'] = self.precision.value
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> DateValue:
+        """Deserializes the DateValue from a dictionary."""
+        return cls(date_value=d.get('date_value', None),
+                   dynamic_date_value=_enum(d, 'dynamic_date_value', DateValueDynamicDate),
+                   precision=_enum(d, 'precision', DatePrecision))
+
+
+class DateValueDynamicDate(Enum):
+
+    NOW = 'NOW'
+    YESTERDAY = 'YESTERDAY'
+
+
 @dataclass
 class DeleteResponse:
 
@@ -942,26 +1483,6 @@ class DeleteWarehouseResponse:
 
 
 class Disposition(Enum):
-    """The fetch disposition provides two modes of fetching results: `INLINE` and `EXTERNAL_LINKS`.
-    
-    Statements executed with `INLINE` disposition will return result data inline, in `JSON_ARRAY`
-    format, in a series of chunks. If a given statement produces a result set with a size larger
-    than 25 MiB, that statement execution is aborted, and no result set will be available.
-    
-    **NOTE** Byte limits are computed based upon internal representations of the result set data,
-    and might not match the sizes visible in JSON responses.
-    
-    Statements executed with `EXTERNAL_LINKS` disposition will return result data as external links:
-    URLs that point to cloud storage internal to the workspace. Using `EXTERNAL_LINKS` disposition
-    allows statements to generate arbitrarily sized result sets for fetching up to 100 GiB. The
-    resulting links have two important properties:
-    
-    1. They point to resources _external_ to the Databricks compute; therefore any associated
-    authentication information (typically a personal access token, OAuth token, or similar) _must be
-    removed_ when fetching from these links.
-    
-    2. These are presigned URLs with a specific expiration, indicated in the response. The behavior
-    when attempting to use an expired link is cloud specific."""
 
     EXTERNAL_LINKS = 'EXTERNAL_LINKS'
     INLINE = 'INLINE'
@@ -1140,6 +1661,50 @@ class EditWarehouseResponse:
         return cls()
 
 
+@dataclass
+class Empty:
+    """Represents an empty message, similar to google.protobuf.Empty, which is not available in the
+    firm right now."""
+
+    def as_dict(self) -> dict:
+        """Serializes the Empty into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> Empty:
+        """Deserializes the Empty from a dictionary."""
+        return cls()
+
+
+@dataclass
+class EncodedText:
+    encoding: Optional[EncodedTextEncoding] = None
+    """Carry text data in different form."""
+
+    text: Optional[str] = None
+    """text data"""
+
+    def as_dict(self) -> dict:
+        """Serializes the EncodedText into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.encoding is not None: body['encoding'] = self.encoding.value
+        if self.text is not None: body['text'] = self.text
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> EncodedText:
+        """Deserializes the EncodedText from a dictionary."""
+        return cls(encoding=_enum(d, 'encoding', EncodedTextEncoding), text=d.get('text', None))
+
+
+class EncodedTextEncoding(Enum):
+    """Carry text data in different form."""
+
+    BASE64 = 'BASE64'
+    PLAIN = 'PLAIN'
+
+
 @dataclass
 class EndpointConfPair:
     key: Optional[str] = None
@@ -1384,14 +1949,42 @@ class EndpointTags:
         return cls(custom_tags=_repeated_dict(d, 'custom_tags', EndpointTagPair))
 
 
+@dataclass
+class EnumValue:
+    enum_options: Optional[str] = None
+    """List of valid query parameter values, newline delimited."""
+
+    multi_values_options: Optional[MultiValuesOptions] = None
+    """If specified, allows multiple values to be selected for this parameter."""
+
+    values: Optional[List[str]] = None
+    """List of selected query parameter values."""
+
+    def as_dict(self) -> dict:
+        """Serializes the EnumValue into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.enum_options is not None: body['enum_options'] = self.enum_options
+        if self.multi_values_options: body['multi_values_options'] = self.multi_values_options.as_dict()
+        if self.values: body['values'] = [v for v in self.values]
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> EnumValue:
+        """Deserializes the EnumValue from a dictionary."""
+        return cls(enum_options=d.get('enum_options', None),
+                   multi_values_options=_from_dict(d, 'multi_values_options', MultiValuesOptions),
+                   values=d.get('values', None))
+
+
 @dataclass
 class ExecuteStatementRequest:
     statement: str
     """The SQL statement to execute. The statement can optionally be parameterized, see `parameters`."""
 
     warehouse_id: str
-    """Warehouse upon which to execute a statement. See also [What are SQL
-    warehouses?](/sql/admin/warehouse-type.html)"""
+    """Warehouse upon which to execute a statement. See also [What are SQL warehouses?]
+    
+    [What are SQL warehouses?]: https://docs.databricks.com/sql/admin/warehouse-type.html"""
 
     byte_limit: Optional[int] = None
     """Applies the given byte limit to the statement's result size. Byte counts are based on internal
@@ -1406,26 +1999,6 @@ class ExecuteStatementRequest:
     [`USE CATALOG`]: https://docs.databricks.com/sql/language-manual/sql-ref-syntax-ddl-use-catalog.html"""
 
     disposition: Optional[Disposition] = None
-    """The fetch disposition provides two modes of fetching results: `INLINE` and `EXTERNAL_LINKS`.
-    
-    Statements executed with `INLINE` disposition will return result data inline, in `JSON_ARRAY`
-    format, in a series of chunks. If a given statement produces a result set with a size larger
-    than 25 MiB, that statement execution is aborted, and no result set will be available.
-    
-    **NOTE** Byte limits are computed based upon internal representations of the result set data,
-    and might not match the sizes visible in JSON responses.
-    
-    Statements executed with `EXTERNAL_LINKS` disposition will return result data as external links:
-    URLs that point to cloud storage internal to the workspace. Using `EXTERNAL_LINKS` disposition
-    allows statements to generate arbitrarily sized result sets for fetching up to 100 GiB. The
-    resulting links have two important properties:
-    
-    1. They point to resources _external_ to the Databricks compute; therefore any associated
-    authentication information (typically a personal access token, OAuth token, or similar) _must be
-    removed_ when fetching from these links.
-    
-    2. These are presigned URLs with a specific expiration, indicated in the response. The behavior
-    when attempting to use an expired link is cloud specific."""
 
     format: Optional[Format] = None
     """Statement execution supports three result formats: `JSON_ARRAY` (default), `ARROW_STREAM`, and
@@ -1564,43 +2137,6 @@ class ExecuteStatementRequestOnWaitTimeout(Enum):
     CONTINUE = 'CONTINUE'
 
 
-@dataclass
-class ExecuteStatementResponse:
-    manifest: Optional[ResultManifest] = None
-    """The result manifest provides schema and metadata for the result set."""
-
-    result: Optional[ResultData] = None
-    """Contains the result data of a single chunk when using `INLINE` disposition. When using
-    `EXTERNAL_LINKS` disposition, the array `external_links` is used instead to provide presigned
-    URLs to the result data in cloud storage. Exactly one of these alternatives is used. (While the
-    `external_links` array prepares the API to return multiple links in a single response. Currently
-    only a single link is returned.)"""
-
-    statement_id: Optional[str] = None
-    """The statement ID is returned upon successfully submitting a SQL statement, and is a required
-    reference for all subsequent calls."""
-
-    status: Optional[StatementStatus] = None
-    """The status response includes execution state and if relevant, error information."""
-
-    def as_dict(self) -> dict:
-        """Serializes the ExecuteStatementResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.manifest: body['manifest'] = self.manifest.as_dict()
-        if self.result: body['result'] = self.result.as_dict()
-        if self.statement_id is not None: body['statement_id'] = self.statement_id
-        if self.status: body['status'] = self.status.as_dict()
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> ExecuteStatementResponse:
-        """Deserializes the ExecuteStatementResponse from a dictionary."""
-        return cls(manifest=_from_dict(d, 'manifest', ResultManifest),
-                   result=_from_dict(d, 'result', ResultData),
-                   statement_id=d.get('statement_id', None),
-                   status=_from_dict(d, 'status', StatementStatus))
-
-
 @dataclass
 class ExternalLink:
     byte_count: Optional[int] = None
@@ -1615,9 +2151,6 @@ class ExternalLink:
     which point a new `external_link` must be requested."""
 
     external_link: Optional[str] = None
-    """A presigned URL pointing to a chunk of result data, hosted by an external service, with a short
-    expiration time (<= 15 minutes). As this URL contains a temporary credential, it should be
-    considered sensitive and the client should not expose this URL in a log."""
 
     http_headers: Optional[Dict[str, str]] = None
     """HTTP headers that must be included with a GET request to the `external_link`. Each header is
@@ -1704,43 +2237,6 @@ class GetResponse:
                    object_type=_enum(d, 'object_type', ObjectType))
 
 
-@dataclass
-class GetStatementResponse:
-    manifest: Optional[ResultManifest] = None
-    """The result manifest provides schema and metadata for the result set."""
-
-    result: Optional[ResultData] = None
-    """Contains the result data of a single chunk when using `INLINE` disposition. When using
-    `EXTERNAL_LINKS` disposition, the array `external_links` is used instead to provide presigned
-    URLs to the result data in cloud storage. Exactly one of these alternatives is used. (While the
-    `external_links` array prepares the API to return multiple links in a single response. Currently
-    only a single link is returned.)"""
-
-    statement_id: Optional[str] = None
-    """The statement ID is returned upon successfully submitting a SQL statement, and is a required
-    reference for all subsequent calls."""
-
-    status: Optional[StatementStatus] = None
-    """The status response includes execution state and if relevant, error information."""
-
-    def as_dict(self) -> dict:
-        """Serializes the GetStatementResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.manifest: body['manifest'] = self.manifest.as_dict()
-        if self.result: body['result'] = self.result.as_dict()
-        if self.statement_id is not None: body['statement_id'] = self.statement_id
-        if self.status: body['status'] = self.status.as_dict()
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> GetStatementResponse:
-        """Deserializes the GetStatementResponse from a dictionary."""
-        return cls(manifest=_from_dict(d, 'manifest', ResultManifest),
-                   result=_from_dict(d, 'result', ResultData),
-                   statement_id=d.get('statement_id', None),
-                   status=_from_dict(d, 'status', StatementStatus))
-
-
 @dataclass
 class GetWarehousePermissionLevelsResponse:
     permission_levels: Optional[List[WarehousePermissionsDescription]] = None
@@ -1986,6 +2482,386 @@ class GetWorkspaceWarehouseConfigResponseSecurityPolicy(Enum):
     PASSTHROUGH = 'PASSTHROUGH'
 
 
+@dataclass
+class LegacyAlert:
+    created_at: Optional[str] = None
+    """Timestamp when the alert was created."""
+
+    id: Optional[str] = None
+    """Alert ID."""
+
+    last_triggered_at: Optional[str] = None
+    """Timestamp when the alert was last triggered."""
+
+    name: Optional[str] = None
+    """Name of the alert."""
+
+    options: Optional[AlertOptions] = None
+    """Alert configuration options."""
+
+    parent: Optional[str] = None
+    """The identifier of the workspace folder containing the object."""
+
+    query: Optional[AlertQuery] = None
+
+    rearm: Optional[int] = None
+    """Number of seconds after being triggered before the alert rearms itself and can be triggered
+    again. If `null`, alert will never be triggered again."""
+
+    state: Optional[LegacyAlertState] = None
+    """State of the alert. Possible values are: `unknown` (yet to be evaluated), `triggered` (evaluated
+    and fulfilled trigger conditions), or `ok` (evaluated and did not fulfill trigger conditions)."""
+
+    updated_at: Optional[str] = None
+    """Timestamp when the alert was last updated."""
+
+    user: Optional[User] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the LegacyAlert into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.id is not None: body['id'] = self.id
+        if self.last_triggered_at is not None: body['last_triggered_at'] = self.last_triggered_at
+        if self.name is not None: body['name'] = self.name
+        if self.options: body['options'] = self.options.as_dict()
+        if self.parent is not None: body['parent'] = self.parent
+        if self.query: body['query'] = self.query.as_dict()
+        if self.rearm is not None: body['rearm'] = self.rearm
+        if self.state is not None: body['state'] = self.state.value
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.user: body['user'] = self.user.as_dict()
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> LegacyAlert:
+        """Deserializes the LegacyAlert from a dictionary."""
+        return cls(created_at=d.get('created_at', None),
+                   id=d.get('id', None),
+                   last_triggered_at=d.get('last_triggered_at', None),
+                   name=d.get('name', None),
+                   options=_from_dict(d, 'options', AlertOptions),
+                   parent=d.get('parent', None),
+                   query=_from_dict(d, 'query', AlertQuery),
+                   rearm=d.get('rearm', None),
+                   state=_enum(d, 'state', LegacyAlertState),
+                   updated_at=d.get('updated_at', None),
+                   user=_from_dict(d, 'user', User))
+
+
+class LegacyAlertState(Enum):
+    """State of the alert. Possible values are: `unknown` (yet to be evaluated), `triggered` (evaluated
+    and fulfilled trigger conditions), or `ok` (evaluated and did not fulfill trigger conditions)."""
+
+    OK = 'ok'
+    TRIGGERED = 'triggered'
+    UNKNOWN = 'unknown'
+
+
+@dataclass
+class LegacyQuery:
+    can_edit: Optional[bool] = None
+    """Describes whether the authenticated user is allowed to edit the definition of this query."""
+
+    created_at: Optional[str] = None
+    """The timestamp when this query was created."""
+
+    data_source_id: Optional[str] = None
+    """Data source ID maps to the ID of the data source used by the resource and is distinct from the
+    warehouse ID. [Learn more]
+    
+    [Learn more]: https://docs.databricks.com/api/workspace/datasources/list"""
+
+    description: Optional[str] = None
+    """General description that conveys additional information about this query such as usage notes."""
+
+    id: Optional[str] = None
+    """Query ID."""
+
+    is_archived: Optional[bool] = None
+    """Indicates whether the query is trashed. Trashed queries can't be used in dashboards, or appear
+    in search results. If this boolean is `true`, the `options` property for this query includes a
+    `moved_to_trash_at` timestamp. Trashed queries are permanently deleted after 30 days."""
+
+    is_draft: Optional[bool] = None
+    """Whether the query is a draft. Draft queries only appear in list views for their owners.
+    Visualizations from draft queries cannot appear on dashboards."""
+
+    is_favorite: Optional[bool] = None
+    """Whether this query object appears in the current user's favorites list. This flag determines
+    whether the star icon for favorites is selected."""
+
+    is_safe: Optional[bool] = None
+    """Text parameter types are not safe from SQL injection for all types of data source. Set this
+    Boolean parameter to `true` if a query either does not use any text type parameters or uses a
+    data source type where text type parameters are handled safely."""
+
+    last_modified_by: Optional[User] = None
+
+    last_modified_by_id: Optional[int] = None
+    """The ID of the user who last saved changes to this query."""
+
+    latest_query_data_id: Optional[str] = None
+    """If there is a cached result for this query and user, this field includes the query result ID. If
+    this query uses parameters, this field is always null."""
+
+    name: Optional[str] = None
+    """The title of this query that appears in list views, widget headings, and on the query page."""
+
+    options: Optional[QueryOptions] = None
+
+    parent: Optional[str] = None
+    """The identifier of the workspace folder containing the object."""
+
+    permission_tier: Optional[PermissionLevel] = None
+    """* `CAN_VIEW`: Can view the query * `CAN_RUN`: Can run the query * `CAN_EDIT`: Can edit the query
+    * `CAN_MANAGE`: Can manage the query"""
+
+    query: Optional[str] = None
+    """The text of the query to be run."""
+
+    query_hash: Optional[str] = None
+    """A SHA-256 hash of the query text along with the authenticated user ID."""
+
+    run_as_role: Optional[RunAsRole] = None
+    """Sets the **Run as** role for the object. Must be set to one of `"viewer"` (signifying "run as
+    viewer" behavior) or `"owner"` (signifying "run as owner" behavior)"""
+
+    tags: Optional[List[str]] = None
+
+    updated_at: Optional[str] = None
+    """The timestamp at which this query was last updated."""
+
+    user: Optional[User] = None
+
+    user_id: Optional[int] = None
+    """The ID of the user who owns the query."""
+
+    visualizations: Optional[List[LegacyVisualization]] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the LegacyQuery into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.can_edit is not None: body['can_edit'] = self.can_edit
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.data_source_id is not None: body['data_source_id'] = self.data_source_id
+        if self.description is not None: body['description'] = self.description
+        if self.id is not None: body['id'] = self.id
+        if self.is_archived is not None: body['is_archived'] = self.is_archived
+        if self.is_draft is not None: body['is_draft'] = self.is_draft
+        if self.is_favorite is not None: body['is_favorite'] = self.is_favorite
+        if self.is_safe is not None: body['is_safe'] = self.is_safe
+        if self.last_modified_by: body['last_modified_by'] = self.last_modified_by.as_dict()
+        if self.last_modified_by_id is not None: body['last_modified_by_id'] = self.last_modified_by_id
+        if self.latest_query_data_id is not None: body['latest_query_data_id'] = self.latest_query_data_id
+        if self.name is not None: body['name'] = self.name
+        if self.options: body['options'] = self.options.as_dict()
+        if self.parent is not None: body['parent'] = self.parent
+        if self.permission_tier is not None: body['permission_tier'] = self.permission_tier.value
+        if self.query is not None: body['query'] = self.query
+        if self.query_hash is not None: body['query_hash'] = self.query_hash
+        if self.run_as_role is not None: body['run_as_role'] = self.run_as_role.value
+        if self.tags: body['tags'] = [v for v in self.tags]
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.user: body['user'] = self.user.as_dict()
+        if self.user_id is not None: body['user_id'] = self.user_id
+        if self.visualizations: body['visualizations'] = [v.as_dict() for v in self.visualizations]
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> LegacyQuery:
+        """Deserializes the LegacyQuery from a dictionary."""
+        return cls(can_edit=d.get('can_edit', None),
+                   created_at=d.get('created_at', None),
+                   data_source_id=d.get('data_source_id', None),
+                   description=d.get('description', None),
+                   id=d.get('id', None),
+                   is_archived=d.get('is_archived', None),
+                   is_draft=d.get('is_draft', None),
+                   is_favorite=d.get('is_favorite', None),
+                   is_safe=d.get('is_safe', None),
+                   last_modified_by=_from_dict(d, 'last_modified_by', User),
+                   last_modified_by_id=d.get('last_modified_by_id', None),
+                   latest_query_data_id=d.get('latest_query_data_id', None),
+                   name=d.get('name', None),
+                   options=_from_dict(d, 'options', QueryOptions),
+                   parent=d.get('parent', None),
+                   permission_tier=_enum(d, 'permission_tier', PermissionLevel),
+                   query=d.get('query', None),
+                   query_hash=d.get('query_hash', None),
+                   run_as_role=_enum(d, 'run_as_role', RunAsRole),
+                   tags=d.get('tags', None),
+                   updated_at=d.get('updated_at', None),
+                   user=_from_dict(d, 'user', User),
+                   user_id=d.get('user_id', None),
+                   visualizations=_repeated_dict(d, 'visualizations', LegacyVisualization))
+
+
+@dataclass
+class LegacyVisualization:
+    """The visualization description API changes frequently and is unsupported. You can duplicate a
+    visualization by copying description objects received _from the API_ and then using them to
+    create a new one with a POST request to the same endpoint. Databricks does not recommend
+    constructing ad-hoc visualizations entirely in JSON."""
+
+    created_at: Optional[str] = None
+
+    description: Optional[str] = None
+    """A short description of this visualization. This is not displayed in the UI."""
+
+    id: Optional[str] = None
+    """The UUID for this visualization."""
+
+    name: Optional[str] = None
+    """The name of the visualization that appears on dashboards and the query screen."""
+
+    options: Optional[Any] = None
+    """The options object varies widely from one visualization type to the next and is unsupported.
+    Databricks does not recommend modifying visualization settings in JSON."""
+
+    query: Optional[LegacyQuery] = None
+
+    type: Optional[str] = None
+    """The type of visualization: chart, table, pivot table, and so on."""
+
+    updated_at: Optional[str] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the LegacyVisualization into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.description is not None: body['description'] = self.description
+        if self.id is not None: body['id'] = self.id
+        if self.name is not None: body['name'] = self.name
+        if self.options: body['options'] = self.options
+        if self.query: body['query'] = self.query.as_dict()
+        if self.type is not None: body['type'] = self.type
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> LegacyVisualization:
+        """Deserializes the LegacyVisualization from a dictionary."""
+        return cls(created_at=d.get('created_at', None),
+                   description=d.get('description', None),
+                   id=d.get('id', None),
+                   name=d.get('name', None),
+                   options=d.get('options', None),
+                   query=_from_dict(d, 'query', LegacyQuery),
+                   type=d.get('type', None),
+                   updated_at=d.get('updated_at', None))
+
+
+class LifecycleState(Enum):
+
+    ACTIVE = 'ACTIVE'
+    TRASHED = 'TRASHED'
+
+
+@dataclass
+class ListAlertsResponse:
+    next_page_token: Optional[str] = None
+
+    results: Optional[List[ListAlertsResponseAlert]] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the ListAlertsResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.results: body['results'] = [v.as_dict() for v in self.results]
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> ListAlertsResponse:
+        """Deserializes the ListAlertsResponse from a dictionary."""
+        return cls(next_page_token=d.get('next_page_token', None),
+                   results=_repeated_dict(d, 'results', ListAlertsResponseAlert))
+
+
+@dataclass
+class ListAlertsResponseAlert:
+    condition: Optional[AlertCondition] = None
+    """Trigger conditions of the alert."""
+
+    create_time: Optional[str] = None
+    """The timestamp indicating when the alert was created."""
+
+    custom_body: Optional[str] = None
+    """Custom body of alert notification, if it exists. See [here] for custom templating instructions.
+    
+    [here]: https://docs.databricks.com/sql/user/alerts/index.html"""
+
+    custom_subject: Optional[str] = None
+    """Custom subject of alert notification, if it exists. This can include email subject entries and
+    Slack notification headers, for example. See [here] for custom templating instructions.
+    
+    [here]: https://docs.databricks.com/sql/user/alerts/index.html"""
+
+    display_name: Optional[str] = None
+    """The display name of the alert."""
+
+    id: Optional[str] = None
+    """UUID identifying the alert."""
+
+    lifecycle_state: Optional[LifecycleState] = None
+    """The workspace state of the alert. Used for tracking trashed status."""
+
+    owner_user_name: Optional[str] = None
+    """The owner's username. This field is set to "Unavailable" if the user has been deleted."""
+
+    query_id: Optional[str] = None
+    """UUID of the query attached to the alert."""
+
+    seconds_to_retrigger: Optional[int] = None
+    """Number of seconds an alert must wait after being triggered to rearm itself. After rearming, it
+    can be triggered again. If 0 or not specified, the alert will not be triggered again."""
+
+    state: Optional[AlertState] = None
+    """Current state of the alert's trigger status. This field is set to UNKNOWN if the alert has not
+    yet been evaluated or ran into an error during the last evaluation."""
+
+    trigger_time: Optional[str] = None
+    """Timestamp when the alert was last triggered, if the alert has been triggered before."""
+
+    update_time: Optional[str] = None
+    """The timestamp indicating when the alert was updated."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ListAlertsResponseAlert into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.condition: body['condition'] = self.condition.as_dict()
+        if self.create_time is not None: body['create_time'] = self.create_time
+        if self.custom_body is not None: body['custom_body'] = self.custom_body
+        if self.custom_subject is not None: body['custom_subject'] = self.custom_subject
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.id is not None: body['id'] = self.id
+        if self.lifecycle_state is not None: body['lifecycle_state'] = self.lifecycle_state.value
+        if self.owner_user_name is not None: body['owner_user_name'] = self.owner_user_name
+        if self.query_id is not None: body['query_id'] = self.query_id
+        if self.seconds_to_retrigger is not None: body['seconds_to_retrigger'] = self.seconds_to_retrigger
+        if self.state is not None: body['state'] = self.state.value
+        if self.trigger_time is not None: body['trigger_time'] = self.trigger_time
+        if self.update_time is not None: body['update_time'] = self.update_time
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> ListAlertsResponseAlert:
+        """Deserializes the ListAlertsResponseAlert from a dictionary."""
+        return cls(condition=_from_dict(d, 'condition', AlertCondition),
+                   create_time=d.get('create_time', None),
+                   custom_body=d.get('custom_body', None),
+                   custom_subject=d.get('custom_subject', None),
+                   display_name=d.get('display_name', None),
+                   id=d.get('id', None),
+                   lifecycle_state=_enum(d, 'lifecycle_state', LifecycleState),
+                   owner_user_name=d.get('owner_user_name', None),
+                   query_id=d.get('query_id', None),
+                   seconds_to_retrigger=d.get('seconds_to_retrigger', None),
+                   state=_enum(d, 'state', AlertState),
+                   trigger_time=d.get('trigger_time', None),
+                   update_time=d.get('update_time', None))
+
+
 class ListOrder(Enum):
 
     CREATED_AT = 'created_at'
@@ -2018,6 +2894,118 @@ class ListQueriesResponse:
                    res=_repeated_dict(d, 'res', QueryInfo))
 
 
+@dataclass
+class ListQueryObjectsResponse:
+    next_page_token: Optional[str] = None
+
+    results: Optional[List[ListQueryObjectsResponseQuery]] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the ListQueryObjectsResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.results: body['results'] = [v.as_dict() for v in self.results]
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> ListQueryObjectsResponse:
+        """Deserializes the ListQueryObjectsResponse from a dictionary."""
+        return cls(next_page_token=d.get('next_page_token', None),
+                   results=_repeated_dict(d, 'results', ListQueryObjectsResponseQuery))
+
+
+@dataclass
+class ListQueryObjectsResponseQuery:
+    apply_auto_limit: Optional[bool] = None
+    """Whether to apply a 1000 row limit to the query result."""
+
+    catalog: Optional[str] = None
+    """Name of the catalog where this query will be executed."""
+
+    create_time: Optional[str] = None
+    """Timestamp when this query was created."""
+
+    description: Optional[str] = None
+    """General description that conveys additional information about this query such as usage notes."""
+
+    display_name: Optional[str] = None
+    """Display name of the query that appears in list views, widget headings, and on the query page."""
+
+    id: Optional[str] = None
+    """UUID identifying the query."""
+
+    last_modifier_user_name: Optional[str] = None
+    """Username of the user who last saved changes to this query."""
+
+    lifecycle_state: Optional[LifecycleState] = None
+    """Indicates whether the query is trashed."""
+
+    owner_user_name: Optional[str] = None
+    """Username of the user that owns the query."""
+
+    parameters: Optional[List[QueryParameter]] = None
+    """List of query parameter definitions."""
+
+    query_text: Optional[str] = None
+    """Text of the query to be run."""
+
+    run_as_mode: Optional[RunAsMode] = None
+    """Sets the "Run as" role for the object."""
+
+    schema: Optional[str] = None
+    """Name of the schema where this query will be executed."""
+
+    tags: Optional[List[str]] = None
+
+    update_time: Optional[str] = None
+    """Timestamp when this query was last updated."""
+
+    warehouse_id: Optional[str] = None
+    """ID of the SQL warehouse attached to the query."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ListQueryObjectsResponseQuery into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.apply_auto_limit is not None: body['apply_auto_limit'] = self.apply_auto_limit
+        if self.catalog is not None: body['catalog'] = self.catalog
+        if self.create_time is not None: body['create_time'] = self.create_time
+        if self.description is not None: body['description'] = self.description
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.id is not None: body['id'] = self.id
+        if self.last_modifier_user_name is not None:
+            body['last_modifier_user_name'] = self.last_modifier_user_name
+        if self.lifecycle_state is not None: body['lifecycle_state'] = self.lifecycle_state.value
+        if self.owner_user_name is not None: body['owner_user_name'] = self.owner_user_name
+        if self.parameters: body['parameters'] = [v.as_dict() for v in self.parameters]
+        if self.query_text is not None: body['query_text'] = self.query_text
+        if self.run_as_mode is not None: body['run_as_mode'] = self.run_as_mode.value
+        if self.schema is not None: body['schema'] = self.schema
+        if self.tags: body['tags'] = [v for v in self.tags]
+        if self.update_time is not None: body['update_time'] = self.update_time
+        if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> ListQueryObjectsResponseQuery:
+        """Deserializes the ListQueryObjectsResponseQuery from a dictionary."""
+        return cls(apply_auto_limit=d.get('apply_auto_limit', None),
+                   catalog=d.get('catalog', None),
+                   create_time=d.get('create_time', None),
+                   description=d.get('description', None),
+                   display_name=d.get('display_name', None),
+                   id=d.get('id', None),
+                   last_modifier_user_name=d.get('last_modifier_user_name', None),
+                   lifecycle_state=_enum(d, 'lifecycle_state', LifecycleState),
+                   owner_user_name=d.get('owner_user_name', None),
+                   parameters=_repeated_dict(d, 'parameters', QueryParameter),
+                   query_text=d.get('query_text', None),
+                   run_as_mode=_enum(d, 'run_as_mode', RunAsMode),
+                   schema=d.get('schema', None),
+                   tags=d.get('tags', None),
+                   update_time=d.get('update_time', None),
+                   warehouse_id=d.get('warehouse_id', None))
+
+
 @dataclass
 class ListResponse:
     count: Optional[int] = None
@@ -2050,6 +3038,26 @@ class ListResponse:
                    results=_repeated_dict(d, 'results', Dashboard))
 
 
+@dataclass
+class ListVisualizationsForQueryResponse:
+    next_page_token: Optional[str] = None
+
+    results: Optional[List[Visualization]] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the ListVisualizationsForQueryResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.results: body['results'] = [v.as_dict() for v in self.results]
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> ListVisualizationsForQueryResponse:
+        """Deserializes the ListVisualizationsForQueryResponse from a dictionary."""
+        return cls(next_page_token=d.get('next_page_token', None),
+                   results=_repeated_dict(d, 'results', Visualization))
+
+
 @dataclass
 class ListWarehousesResponse:
     warehouses: Optional[List[EndpointInfo]] = None
@@ -2069,9 +3077,6 @@ class ListWarehousesResponse:
 
 @dataclass
 class MultiValuesOptions:
-    """If specified, allows multiple values to be selected for this parameter. Only applies to dropdown
-    list and query-based dropdown list parameters."""
-
     prefix: Optional[str] = None
     """Character that prefixes each selected parameter value."""
 
@@ -2097,6 +3102,22 @@ class MultiValuesOptions:
                    suffix=d.get('suffix', None))
 
 
+@dataclass
+class NumericValue:
+    value: Optional[float] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the NumericValue into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.value is not None: body['value'] = self.value
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> NumericValue:
+        """Deserializes the NumericValue from a dictionary."""
+        return cls(value=d.get('value', None))
+
+
 class ObjectType(Enum):
     """A singular noun object type."""
 
@@ -2221,7 +3242,7 @@ class PermissionLevel(Enum):
 
 
 class PlansState(Enum):
-    """Whether plans exist for the execution, or the reason why they are missing"""
+    """Possible Reasons for which we have not saved plans in the database"""
 
     EMPTY = 'EMPTY'
     EXISTS = 'EXISTS'
@@ -2231,150 +3252,135 @@ class PlansState(Enum):
     UNKNOWN = 'UNKNOWN'
 
 
-@dataclass
-class Query:
-    can_edit: Optional[bool] = None
-    """Describes whether the authenticated user is allowed to edit the definition of this query."""
-
-    created_at: Optional[str] = None
-    """The timestamp when this query was created."""
-
-    data_source_id: Optional[str] = None
-    """Data source ID maps to the ID of the data source used by the resource and is distinct from the
-    warehouse ID. [Learn more].
-    
-    [Learn more]: https://docs.databricks.com/api/workspace/datasources/list"""
-
-    description: Optional[str] = None
-    """General description that conveys additional information about this query such as usage notes."""
-
-    id: Optional[str] = None
-    """Query ID."""
-
-    is_archived: Optional[bool] = None
-    """Indicates whether the query is trashed. Trashed queries can't be used in dashboards, or appear
-    in search results. If this boolean is `true`, the `options` property for this query includes a
-    `moved_to_trash_at` timestamp. Trashed queries are permanently deleted after 30 days."""
-
-    is_draft: Optional[bool] = None
-    """Whether the query is a draft. Draft queries only appear in list views for their owners.
-    Visualizations from draft queries cannot appear on dashboards."""
-
-    is_favorite: Optional[bool] = None
-    """Whether this query object appears in the current user's favorites list. This flag determines
-    whether the star icon for favorites is selected."""
-
-    is_safe: Optional[bool] = None
-    """Text parameter types are not safe from SQL injection for all types of data source. Set this
-    Boolean parameter to `true` if a query either does not use any text type parameters or uses a
-    data source type where text type parameters are handled safely."""
+@dataclass
+class Query:
+    apply_auto_limit: Optional[bool] = None
+    """Whether to apply a 1000 row limit to the query result."""
 
-    last_modified_by: Optional[User] = None
+    catalog: Optional[str] = None
+    """Name of the catalog where this query will be executed."""
 
-    last_modified_by_id: Optional[int] = None
-    """The ID of the user who last saved changes to this query."""
+    create_time: Optional[str] = None
+    """Timestamp when this query was created."""
 
-    latest_query_data_id: Optional[str] = None
-    """If there is a cached result for this query and user, this field includes the query result ID. If
-    this query uses parameters, this field is always null."""
+    description: Optional[str] = None
+    """General description that conveys additional information about this query such as usage notes."""
 
-    name: Optional[str] = None
-    """The title of this query that appears in list views, widget headings, and on the query page."""
+    display_name: Optional[str] = None
+    """Display name of the query that appears in list views, widget headings, and on the query page."""
 
-    options: Optional[QueryOptions] = None
+    id: Optional[str] = None
+    """UUID identifying the query."""
 
-    parent: Optional[str] = None
-    """The identifier of the workspace folder containing the object."""
+    last_modifier_user_name: Optional[str] = None
+    """Username of the user who last saved changes to this query."""
 
-    permission_tier: Optional[PermissionLevel] = None
-    """* `CAN_VIEW`: Can view the query * `CAN_RUN`: Can run the query * `CAN_EDIT`: Can edit the query
-    * `CAN_MANAGE`: Can manage the query"""
+    lifecycle_state: Optional[LifecycleState] = None
+    """Indicates whether the query is trashed."""
 
-    query: Optional[str] = None
-    """The text of the query to be run."""
+    owner_user_name: Optional[str] = None
+    """Username of the user that owns the query."""
 
-    query_hash: Optional[str] = None
-    """A SHA-256 hash of the query text along with the authenticated user ID."""
+    parameters: Optional[List[QueryParameter]] = None
+    """List of query parameter definitions."""
 
-    run_as_role: Optional[RunAsRole] = None
-    """Sets the **Run as** role for the object. Must be set to one of `"viewer"` (signifying "run as
-    viewer" behavior) or `"owner"` (signifying "run as owner" behavior)"""
+    parent_path: Optional[str] = None
+    """Workspace path of the workspace folder containing the object."""
 
-    tags: Optional[List[str]] = None
+    query_text: Optional[str] = None
+    """Text of the query to be run."""
 
-    updated_at: Optional[str] = None
-    """The timestamp at which this query was last updated."""
+    run_as_mode: Optional[RunAsMode] = None
+    """Sets the "Run as" role for the object."""
 
-    user: Optional[User] = None
+    schema: Optional[str] = None
+    """Name of the schema where this query will be executed."""
 
-    user_id: Optional[int] = None
-    """The ID of the user who owns the query."""
+    tags: Optional[List[str]] = None
+
+    update_time: Optional[str] = None
+    """Timestamp when this query was last updated."""
 
-    visualizations: Optional[List[Visualization]] = None
+    warehouse_id: Optional[str] = None
+    """ID of the SQL warehouse attached to the query."""
 
     def as_dict(self) -> dict:
         """Serializes the Query into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.can_edit is not None: body['can_edit'] = self.can_edit
-        if self.created_at is not None: body['created_at'] = self.created_at
-        if self.data_source_id is not None: body['data_source_id'] = self.data_source_id
+        if self.apply_auto_limit is not None: body['apply_auto_limit'] = self.apply_auto_limit
+        if self.catalog is not None: body['catalog'] = self.catalog
+        if self.create_time is not None: body['create_time'] = self.create_time
         if self.description is not None: body['description'] = self.description
+        if self.display_name is not None: body['display_name'] = self.display_name
         if self.id is not None: body['id'] = self.id
-        if self.is_archived is not None: body['is_archived'] = self.is_archived
-        if self.is_draft is not None: body['is_draft'] = self.is_draft
-        if self.is_favorite is not None: body['is_favorite'] = self.is_favorite
-        if self.is_safe is not None: body['is_safe'] = self.is_safe
-        if self.last_modified_by: body['last_modified_by'] = self.last_modified_by.as_dict()
-        if self.last_modified_by_id is not None: body['last_modified_by_id'] = self.last_modified_by_id
-        if self.latest_query_data_id is not None: body['latest_query_data_id'] = self.latest_query_data_id
-        if self.name is not None: body['name'] = self.name
-        if self.options: body['options'] = self.options.as_dict()
-        if self.parent is not None: body['parent'] = self.parent
-        if self.permission_tier is not None: body['permission_tier'] = self.permission_tier.value
-        if self.query is not None: body['query'] = self.query
-        if self.query_hash is not None: body['query_hash'] = self.query_hash
-        if self.run_as_role is not None: body['run_as_role'] = self.run_as_role.value
+        if self.last_modifier_user_name is not None:
+            body['last_modifier_user_name'] = self.last_modifier_user_name
+        if self.lifecycle_state is not None: body['lifecycle_state'] = self.lifecycle_state.value
+        if self.owner_user_name is not None: body['owner_user_name'] = self.owner_user_name
+        if self.parameters: body['parameters'] = [v.as_dict() for v in self.parameters]
+        if self.parent_path is not None: body['parent_path'] = self.parent_path
+        if self.query_text is not None: body['query_text'] = self.query_text
+        if self.run_as_mode is not None: body['run_as_mode'] = self.run_as_mode.value
+        if self.schema is not None: body['schema'] = self.schema
         if self.tags: body['tags'] = [v for v in self.tags]
-        if self.updated_at is not None: body['updated_at'] = self.updated_at
-        if self.user: body['user'] = self.user.as_dict()
-        if self.user_id is not None: body['user_id'] = self.user_id
-        if self.visualizations: body['visualizations'] = [v.as_dict() for v in self.visualizations]
+        if self.update_time is not None: body['update_time'] = self.update_time
+        if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
         return body
 
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> Query:
         """Deserializes the Query from a dictionary."""
-        return cls(can_edit=d.get('can_edit', None),
-                   created_at=d.get('created_at', None),
-                   data_source_id=d.get('data_source_id', None),
+        return cls(apply_auto_limit=d.get('apply_auto_limit', None),
+                   catalog=d.get('catalog', None),
+                   create_time=d.get('create_time', None),
                    description=d.get('description', None),
+                   display_name=d.get('display_name', None),
                    id=d.get('id', None),
-                   is_archived=d.get('is_archived', None),
-                   is_draft=d.get('is_draft', None),
-                   is_favorite=d.get('is_favorite', None),
-                   is_safe=d.get('is_safe', None),
-                   last_modified_by=_from_dict(d, 'last_modified_by', User),
-                   last_modified_by_id=d.get('last_modified_by_id', None),
-                   latest_query_data_id=d.get('latest_query_data_id', None),
-                   name=d.get('name', None),
-                   options=_from_dict(d, 'options', QueryOptions),
-                   parent=d.get('parent', None),
-                   permission_tier=_enum(d, 'permission_tier', PermissionLevel),
-                   query=d.get('query', None),
-                   query_hash=d.get('query_hash', None),
-                   run_as_role=_enum(d, 'run_as_role', RunAsRole),
+                   last_modifier_user_name=d.get('last_modifier_user_name', None),
+                   lifecycle_state=_enum(d, 'lifecycle_state', LifecycleState),
+                   owner_user_name=d.get('owner_user_name', None),
+                   parameters=_repeated_dict(d, 'parameters', QueryParameter),
+                   parent_path=d.get('parent_path', None),
+                   query_text=d.get('query_text', None),
+                   run_as_mode=_enum(d, 'run_as_mode', RunAsMode),
+                   schema=d.get('schema', None),
                    tags=d.get('tags', None),
-                   updated_at=d.get('updated_at', None),
-                   user=_from_dict(d, 'user', User),
-                   user_id=d.get('user_id', None),
-                   visualizations=_repeated_dict(d, 'visualizations', Visualization))
+                   update_time=d.get('update_time', None),
+                   warehouse_id=d.get('warehouse_id', None))
+
+
+@dataclass
+class QueryBackedValue:
+    multi_values_options: Optional[MultiValuesOptions] = None
+    """If specified, allows multiple values to be selected for this parameter."""
+
+    query_id: Optional[str] = None
+    """UUID of the query that provides the parameter values."""
+
+    values: Optional[List[str]] = None
+    """List of selected query parameter values."""
+
+    def as_dict(self) -> dict:
+        """Serializes the QueryBackedValue into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.multi_values_options: body['multi_values_options'] = self.multi_values_options.as_dict()
+        if self.query_id is not None: body['query_id'] = self.query_id
+        if self.values: body['values'] = [v for v in self.values]
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> QueryBackedValue:
+        """Deserializes the QueryBackedValue from a dictionary."""
+        return cls(multi_values_options=_from_dict(d, 'multi_values_options', MultiValuesOptions),
+                   query_id=d.get('query_id', None),
+                   values=d.get('values', None))
 
 
 @dataclass
 class QueryEditContent:
     data_source_id: Optional[str] = None
     """Data source ID maps to the ID of the data source used by the resource and is distinct from the
-    warehouse ID. [Learn more].
+    warehouse ID. [Learn more]
     
     [Learn more]: https://docs.databricks.com/api/workspace/datasources/list"""
 
@@ -2428,12 +3434,11 @@ class QueryEditContent:
 
 @dataclass
 class QueryFilter:
-    """A filter to limit query history results. This field is optional."""
+    context_filter: Optional[ContextFilter] = None
+    """Filter by one or more property describing where the query was generated"""
 
     query_start_time_range: Optional[TimeRange] = None
-
-    statement_ids: Optional[List[str]] = None
-    """A list of statement IDs."""
+    """A range filter for query submitted time. The time range must be <= 30 days."""
 
     statuses: Optional[List[QueryStatus]] = None
 
@@ -2446,8 +3451,8 @@ class QueryFilter:
     def as_dict(self) -> dict:
         """Serializes the QueryFilter into a dictionary suitable for use as a JSON request body."""
         body = {}
+        if self.context_filter: body['context_filter'] = self.context_filter.as_dict()
         if self.query_start_time_range: body['query_start_time_range'] = self.query_start_time_range.as_dict()
-        if self.statement_ids: body['statement_ids'] = [v for v in self.statement_ids]
         if self.statuses: body['statuses'] = [v.value for v in self.statuses]
         if self.user_ids: body['user_ids'] = [v for v in self.user_ids]
         if self.warehouse_ids: body['warehouse_ids'] = [v for v in self.warehouse_ids]
@@ -2456,8 +3461,8 @@ class QueryFilter:
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> QueryFilter:
         """Deserializes the QueryFilter from a dictionary."""
-        return cls(query_start_time_range=_from_dict(d, 'query_start_time_range', TimeRange),
-                   statement_ids=d.get('statement_ids', None),
+        return cls(context_filter=_from_dict(d, 'context_filter', ContextFilter),
+                   query_start_time_range=_from_dict(d, 'query_start_time_range', TimeRange),
                    statuses=_repeated_enum(d, 'statuses', QueryStatus),
                    user_ids=d.get('user_ids', None),
                    warehouse_ids=d.get('warehouse_ids', None))
@@ -2465,14 +3470,11 @@ class QueryFilter:
 
 @dataclass
 class QueryInfo:
-    can_subscribe_to_live_query: Optional[bool] = None
-    """Reserved for internal use."""
-
     channel_used: Optional[ChannelInfo] = None
-    """Channel information for the SQL warehouse at the time of query execution"""
+    """SQL Warehouse channel information at the time of query execution"""
 
     duration: Optional[int] = None
-    """Total execution time of the query from the client’s point of view, in milliseconds."""
+    """Total execution time of the statement ( excluding result fetch time )."""
 
     endpoint_id: Optional[str] = None
     """Alias for `warehouse_id`."""
@@ -2507,6 +3509,8 @@ class QueryInfo:
     query_id: Optional[str] = None
     """The query ID."""
 
+    query_source: Optional[QuerySource] = None
+
     query_start_time_ms: Optional[int] = None
     """The time the query started."""
 
@@ -2517,15 +3521,17 @@ class QueryInfo:
     """The number of results returned by the query."""
 
     spark_ui_url: Optional[str] = None
-    """URL to the query plan."""
+    """URL to the Spark UI query plan."""
 
     statement_type: Optional[QueryStatementType] = None
     """Type of statement for this query"""
 
     status: Optional[QueryStatus] = None
-    """Query status with one the following values: * `QUEUED`: Query has been received and queued. *
-    `RUNNING`: Query has started. * `CANCELED`: Query has been cancelled by the user. * `FAILED`:
-    Query has failed. * `FINISHED`: Query has completed."""
+    """Query status with one the following values:
+    
+    - `QUEUED`: Query has been received and queued. - `RUNNING`: Query has started. - `CANCELED`:
+    Query has been cancelled by the user. - `FAILED`: Query has failed. - `FINISHED`: Query has
+    completed."""
 
     user_id: Optional[int] = None
     """The ID of the user who ran the query."""
@@ -2539,8 +3545,6 @@ class QueryInfo:
     def as_dict(self) -> dict:
         """Serializes the QueryInfo into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.can_subscribe_to_live_query is not None:
-            body['canSubscribeToLiveQuery'] = self.can_subscribe_to_live_query
         if self.channel_used: body['channel_used'] = self.channel_used.as_dict()
         if self.duration is not None: body['duration'] = self.duration
         if self.endpoint_id is not None: body['endpoint_id'] = self.endpoint_id
@@ -2554,6 +3558,7 @@ class QueryInfo:
         if self.plans_state is not None: body['plans_state'] = self.plans_state.value
         if self.query_end_time_ms is not None: body['query_end_time_ms'] = self.query_end_time_ms
         if self.query_id is not None: body['query_id'] = self.query_id
+        if self.query_source: body['query_source'] = self.query_source.as_dict()
         if self.query_start_time_ms is not None: body['query_start_time_ms'] = self.query_start_time_ms
         if self.query_text is not None: body['query_text'] = self.query_text
         if self.rows_produced is not None: body['rows_produced'] = self.rows_produced
@@ -2568,8 +3573,7 @@ class QueryInfo:
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> QueryInfo:
         """Deserializes the QueryInfo from a dictionary."""
-        return cls(can_subscribe_to_live_query=d.get('canSubscribeToLiveQuery', None),
-                   channel_used=_from_dict(d, 'channel_used', ChannelInfo),
+        return cls(channel_used=_from_dict(d, 'channel_used', ChannelInfo),
                    duration=d.get('duration', None),
                    endpoint_id=d.get('endpoint_id', None),
                    error_message=d.get('error_message', None),
@@ -2582,6 +3586,7 @@ class QueryInfo:
                    plans_state=_enum(d, 'plans_state', PlansState),
                    query_end_time_ms=d.get('query_end_time_ms', None),
                    query_id=d.get('query_id', None),
+                   query_source=_from_dict(d, 'query_source', QuerySource),
                    query_start_time_ms=d.get('query_start_time_ms', None),
                    query_text=d.get('query_text', None),
                    rows_produced=d.get('rows_produced', None),
@@ -2604,7 +3609,7 @@ class QueryList:
     page_size: Optional[int] = None
     """The number of queries per page."""
 
-    results: Optional[List[Query]] = None
+    results: Optional[List[LegacyQuery]] = None
     """List of queries returned."""
 
     def as_dict(self) -> dict:
@@ -2622,12 +3627,13 @@ class QueryList:
         return cls(count=d.get('count', None),
                    page=d.get('page', None),
                    page_size=d.get('page_size', None),
-                   results=_repeated_dict(d, 'results', Query))
+                   results=_repeated_dict(d, 'results', LegacyQuery))
 
 
 @dataclass
 class QueryMetrics:
-    """Metrics about query execution."""
+    """A query metric that encapsulates a set of measurements for a single query. Metrics come from the
+    driver and are stored in the history service database."""
 
     compilation_time_ms: Optional[int] = None
     """Time spent loading metadata and optimizing the query, in milliseconds."""
@@ -2635,9 +3641,6 @@ class QueryMetrics:
     execution_time_ms: Optional[int] = None
     """Time spent executing the query, in milliseconds."""
 
-    metadata_time_ms: Optional[int] = None
-    """Reserved for internal use."""
-
     network_sent_bytes: Optional[int] = None
     """Total amount of data sent over the network between executor nodes during shuffle, in bytes."""
 
@@ -2648,9 +3651,6 @@ class QueryMetrics:
     photon_total_time_ms: Optional[int] = None
     """Total execution time for all individual Photon query engine tasks in the query, in milliseconds."""
 
-    planning_time_ms: Optional[int] = None
-    """Reserved for internal use."""
-
     provisioning_queue_start_timestamp: Optional[int] = None
     """Timestamp of when the query was enqueued waiting for a cluster to be provisioned for the
     warehouse. This field is optional and will not appear if the query skipped the provisioning
@@ -2665,9 +3665,6 @@ class QueryMetrics:
     query_compilation_start_timestamp: Optional[int] = None
     """Timestamp of when the underlying compute started compilation of the query."""
 
-    query_execution_time_ms: Optional[int] = None
-    """Reserved for internal use."""
-
     read_bytes: Optional[int] = None
     """Total size of data read by the query, in bytes."""
 
@@ -2675,7 +3672,7 @@ class QueryMetrics:
     """Size of persistent data read from the cache, in bytes."""
 
     read_files_count: Optional[int] = None
-    """Number of files read after pruning."""
+    """Number of files read after pruning"""
 
     read_partitions_count: Optional[int] = None
     """Number of partitions read after pruning."""
@@ -2687,7 +3684,7 @@ class QueryMetrics:
     """Time spent fetching the query results after the execution finished, in milliseconds."""
 
     result_from_cache: Optional[bool] = None
-    """true if the query result was fetched from cache, false otherwise."""
+    """`true` if the query result was fetched from cache, `false` otherwise."""
 
     rows_produced_count: Optional[int] = None
     """Total number of rows returned by the query."""
@@ -2712,20 +3709,16 @@ class QueryMetrics:
         body = {}
         if self.compilation_time_ms is not None: body['compilation_time_ms'] = self.compilation_time_ms
         if self.execution_time_ms is not None: body['execution_time_ms'] = self.execution_time_ms
-        if self.metadata_time_ms is not None: body['metadata_time_ms'] = self.metadata_time_ms
         if self.network_sent_bytes is not None: body['network_sent_bytes'] = self.network_sent_bytes
         if self.overloading_queue_start_timestamp is not None:
             body['overloading_queue_start_timestamp'] = self.overloading_queue_start_timestamp
         if self.photon_total_time_ms is not None: body['photon_total_time_ms'] = self.photon_total_time_ms
-        if self.planning_time_ms is not None: body['planning_time_ms'] = self.planning_time_ms
         if self.provisioning_queue_start_timestamp is not None:
             body['provisioning_queue_start_timestamp'] = self.provisioning_queue_start_timestamp
         if self.pruned_bytes is not None: body['pruned_bytes'] = self.pruned_bytes
         if self.pruned_files_count is not None: body['pruned_files_count'] = self.pruned_files_count
         if self.query_compilation_start_timestamp is not None:
             body['query_compilation_start_timestamp'] = self.query_compilation_start_timestamp
-        if self.query_execution_time_ms is not None:
-            body['query_execution_time_ms'] = self.query_execution_time_ms
         if self.read_bytes is not None: body['read_bytes'] = self.read_bytes
         if self.read_cache_bytes is not None: body['read_cache_bytes'] = self.read_cache_bytes
         if self.read_files_count is not None: body['read_files_count'] = self.read_files_count
@@ -2746,16 +3739,13 @@ class QueryMetrics:
         """Deserializes the QueryMetrics from a dictionary."""
         return cls(compilation_time_ms=d.get('compilation_time_ms', None),
                    execution_time_ms=d.get('execution_time_ms', None),
-                   metadata_time_ms=d.get('metadata_time_ms', None),
                    network_sent_bytes=d.get('network_sent_bytes', None),
                    overloading_queue_start_timestamp=d.get('overloading_queue_start_timestamp', None),
                    photon_total_time_ms=d.get('photon_total_time_ms', None),
-                   planning_time_ms=d.get('planning_time_ms', None),
                    provisioning_queue_start_timestamp=d.get('provisioning_queue_start_timestamp', None),
                    pruned_bytes=d.get('pruned_bytes', None),
                    pruned_files_count=d.get('pruned_files_count', None),
                    query_compilation_start_timestamp=d.get('query_compilation_start_timestamp', None),
-                   query_execution_time_ms=d.get('query_execution_time_ms', None),
                    read_bytes=d.get('read_bytes', None),
                    read_cache_bytes=d.get('read_cache_bytes', None),
                    read_files_count=d.get('read_files_count', None),
@@ -2803,11 +3793,64 @@ class QueryOptions:
                    schema=d.get('schema', None))
 
 
+@dataclass
+class QueryParameter:
+    date_range_value: Optional[DateRangeValue] = None
+    """Date-range query parameter value. Can only specify one of `dynamic_date_range_value` or
+    `date_range_value`."""
+
+    date_value: Optional[DateValue] = None
+    """Date query parameter value. Can only specify one of `dynamic_date_value` or `date_value`."""
+
+    enum_value: Optional[EnumValue] = None
+    """Dropdown query parameter value."""
+
+    name: Optional[str] = None
+    """Literal parameter marker that appears between double curly braces in the query text."""
+
+    numeric_value: Optional[NumericValue] = None
+    """Numeric query parameter value."""
+
+    query_backed_value: Optional[QueryBackedValue] = None
+    """Query-based dropdown query parameter value."""
+
+    text_value: Optional[TextValue] = None
+    """Text query parameter value."""
+
+    title: Optional[str] = None
+    """Text displayed in the user-facing parameter widget in the UI."""
+
+    def as_dict(self) -> dict:
+        """Serializes the QueryParameter into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.date_range_value: body['date_range_value'] = self.date_range_value.as_dict()
+        if self.date_value: body['date_value'] = self.date_value.as_dict()
+        if self.enum_value: body['enum_value'] = self.enum_value.as_dict()
+        if self.name is not None: body['name'] = self.name
+        if self.numeric_value: body['numeric_value'] = self.numeric_value.as_dict()
+        if self.query_backed_value: body['query_backed_value'] = self.query_backed_value.as_dict()
+        if self.text_value: body['text_value'] = self.text_value.as_dict()
+        if self.title is not None: body['title'] = self.title
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> QueryParameter:
+        """Deserializes the QueryParameter from a dictionary."""
+        return cls(date_range_value=_from_dict(d, 'date_range_value', DateRangeValue),
+                   date_value=_from_dict(d, 'date_value', DateValue),
+                   enum_value=_from_dict(d, 'enum_value', EnumValue),
+                   name=d.get('name', None),
+                   numeric_value=_from_dict(d, 'numeric_value', NumericValue),
+                   query_backed_value=_from_dict(d, 'query_backed_value', QueryBackedValue),
+                   text_value=_from_dict(d, 'text_value', TextValue),
+                   title=d.get('title', None))
+
+
 @dataclass
 class QueryPostContent:
     data_source_id: Optional[str] = None
     """Data source ID maps to the ID of the data source used by the resource and is distinct from the
-    warehouse ID. [Learn more].
+    warehouse ID. [Learn more]
     
     [Learn more]: https://docs.databricks.com/api/workspace/datasources/list"""
 
@@ -2860,8 +3903,187 @@ class QueryPostContent:
                    tags=d.get('tags', None))
 
 
+@dataclass
+class QuerySource:
+    alert_id: Optional[str] = None
+    """UUID"""
+
+    client_call_context: Optional[ClientCallContext] = None
+    """Client code that triggered the request"""
+
+    command_id: Optional[str] = None
+    """Id associated with a notebook cell"""
+
+    command_run_id: Optional[str] = None
+    """Id associated with a notebook run or execution"""
+
+    dashboard_id: Optional[str] = None
+    """UUID"""
+
+    dashboard_v3_id: Optional[str] = None
+    """UUID for Lakeview Dashboards, separate from DBSQL Dashboards (dashboard_id)"""
+
+    driver_info: Optional[QuerySourceDriverInfo] = None
+
+    entry_point: Optional[QuerySourceEntryPoint] = None
+    """Spark service that received and processed the query"""
+
+    genie_space_id: Optional[str] = None
+    """UUID for Genie space"""
+
+    is_cloud_fetch: Optional[bool] = None
+
+    is_databricks_sql_exec_api: Optional[bool] = None
+
+    job_id: Optional[str] = None
+
+    job_managed_by: Optional[QuerySourceJobManager] = None
+    """With background compute, jobs can be managed by different internal teams. When not specified,
+    not a background compute job When specified and the value is not JOBS, it is a background
+    compute job"""
+
+    notebook_id: Optional[str] = None
+
+    pipeline_id: Optional[str] = None
+    """Id associated with a DLT pipeline"""
+
+    pipeline_update_id: Optional[str] = None
+    """Id associated with a DLT update"""
+
+    query_tags: Optional[str] = None
+    """String provided by a customer that'll help them identify the query"""
+
+    run_id: Optional[str] = None
+    """Id associated with a job run or execution"""
+
+    runnable_command_id: Optional[str] = None
+    """Id associated with a notebook cell run or execution"""
+
+    scheduled_by: Optional[QuerySourceTrigger] = None
+
+    serverless_channel_info: Optional[ServerlessChannelInfo] = None
+
+    source_query_id: Optional[str] = None
+    """UUID"""
+
+    def as_dict(self) -> dict:
+        """Serializes the QuerySource into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.alert_id is not None: body['alert_id'] = self.alert_id
+        if self.client_call_context: body['client_call_context'] = self.client_call_context.as_dict()
+        if self.command_id is not None: body['command_id'] = self.command_id
+        if self.command_run_id is not None: body['command_run_id'] = self.command_run_id
+        if self.dashboard_id is not None: body['dashboard_id'] = self.dashboard_id
+        if self.dashboard_v3_id is not None: body['dashboard_v3_id'] = self.dashboard_v3_id
+        if self.driver_info: body['driver_info'] = self.driver_info.as_dict()
+        if self.entry_point is not None: body['entry_point'] = self.entry_point.value
+        if self.genie_space_id is not None: body['genie_space_id'] = self.genie_space_id
+        if self.is_cloud_fetch is not None: body['is_cloud_fetch'] = self.is_cloud_fetch
+        if self.is_databricks_sql_exec_api is not None:
+            body['is_databricks_sql_exec_api'] = self.is_databricks_sql_exec_api
+        if self.job_id is not None: body['job_id'] = self.job_id
+        if self.job_managed_by is not None: body['job_managed_by'] = self.job_managed_by.value
+        if self.notebook_id is not None: body['notebook_id'] = self.notebook_id
+        if self.pipeline_id is not None: body['pipeline_id'] = self.pipeline_id
+        if self.pipeline_update_id is not None: body['pipeline_update_id'] = self.pipeline_update_id
+        if self.query_tags is not None: body['query_tags'] = self.query_tags
+        if self.run_id is not None: body['run_id'] = self.run_id
+        if self.runnable_command_id is not None: body['runnable_command_id'] = self.runnable_command_id
+        if self.scheduled_by is not None: body['scheduled_by'] = self.scheduled_by.value
+        if self.serverless_channel_info:
+            body['serverless_channel_info'] = self.serverless_channel_info.as_dict()
+        if self.source_query_id is not None: body['source_query_id'] = self.source_query_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> QuerySource:
+        """Deserializes the QuerySource from a dictionary."""
+        return cls(alert_id=d.get('alert_id', None),
+                   client_call_context=_from_dict(d, 'client_call_context', ClientCallContext),
+                   command_id=d.get('command_id', None),
+                   command_run_id=d.get('command_run_id', None),
+                   dashboard_id=d.get('dashboard_id', None),
+                   dashboard_v3_id=d.get('dashboard_v3_id', None),
+                   driver_info=_from_dict(d, 'driver_info', QuerySourceDriverInfo),
+                   entry_point=_enum(d, 'entry_point', QuerySourceEntryPoint),
+                   genie_space_id=d.get('genie_space_id', None),
+                   is_cloud_fetch=d.get('is_cloud_fetch', None),
+                   is_databricks_sql_exec_api=d.get('is_databricks_sql_exec_api', None),
+                   job_id=d.get('job_id', None),
+                   job_managed_by=_enum(d, 'job_managed_by', QuerySourceJobManager),
+                   notebook_id=d.get('notebook_id', None),
+                   pipeline_id=d.get('pipeline_id', None),
+                   pipeline_update_id=d.get('pipeline_update_id', None),
+                   query_tags=d.get('query_tags', None),
+                   run_id=d.get('run_id', None),
+                   runnable_command_id=d.get('runnable_command_id', None),
+                   scheduled_by=_enum(d, 'scheduled_by', QuerySourceTrigger),
+                   serverless_channel_info=_from_dict(d, 'serverless_channel_info', ServerlessChannelInfo),
+                   source_query_id=d.get('source_query_id', None))
+
+
+@dataclass
+class QuerySourceDriverInfo:
+    bi_tool_entry: Optional[str] = None
+
+    driver_name: Optional[str] = None
+
+    simba_branding_vendor: Optional[str] = None
+
+    version_number: Optional[str] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the QuerySourceDriverInfo into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.bi_tool_entry is not None: body['bi_tool_entry'] = self.bi_tool_entry
+        if self.driver_name is not None: body['driver_name'] = self.driver_name
+        if self.simba_branding_vendor is not None: body['simba_branding_vendor'] = self.simba_branding_vendor
+        if self.version_number is not None: body['version_number'] = self.version_number
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> QuerySourceDriverInfo:
+        """Deserializes the QuerySourceDriverInfo from a dictionary."""
+        return cls(bi_tool_entry=d.get('bi_tool_entry', None),
+                   driver_name=d.get('driver_name', None),
+                   simba_branding_vendor=d.get('simba_branding_vendor', None),
+                   version_number=d.get('version_number', None))
+
+
+class QuerySourceEntryPoint(Enum):
+    """Spark service that received and processed the query"""
+
+    DLT = 'DLT'
+    SPARK_CONNECT = 'SPARK_CONNECT'
+    THRIFT_SERVER = 'THRIFT_SERVER'
+
+
+class QuerySourceJobManager(Enum):
+    """Copied from elastic-spark-common/api/messages/manager.proto with enum values changed by 1 to
+    accommodate JOB_MANAGER_UNSPECIFIED"""
+
+    APP_SYSTEM_TABLE = 'APP_SYSTEM_TABLE'
+    AUTOML = 'AUTOML'
+    AUTO_MAINTENANCE = 'AUTO_MAINTENANCE'
+    CLEAN_ROOMS = 'CLEAN_ROOMS'
+    DATA_MONITORING = 'DATA_MONITORING'
+    DATA_SHARING = 'DATA_SHARING'
+    ENCRYPTION = 'ENCRYPTION'
+    FABRIC_CRAWLER = 'FABRIC_CRAWLER'
+    JOBS = 'JOBS'
+    LAKEVIEW = 'LAKEVIEW'
+    MANAGED_RAG = 'MANAGED_RAG'
+    SCHEDULED_MV_REFRESH = 'SCHEDULED_MV_REFRESH'
+    TESTING = 'TESTING'
+
+
+class QuerySourceTrigger(Enum):
+
+    MANUAL = 'MANUAL'
+    SCHEDULED = 'SCHEDULED'
+
+
 class QueryStatementType(Enum):
-    """Type of statement for this query"""
 
     ALTER = 'ALTER'
     ANALYZE = 'ANALYZE'
@@ -2888,15 +4110,16 @@ class QueryStatementType(Enum):
 
 
 class QueryStatus(Enum):
-    """Query status with one the following values: * `QUEUED`: Query has been received and queued. *
-    `RUNNING`: Query has started. * `CANCELED`: Query has been cancelled by the user. * `FAILED`:
-    Query has failed. * `FINISHED`: Query has completed."""
+    """Statuses which are also used by OperationStatus in runtime"""
 
     CANCELED = 'CANCELED'
+    COMPILED = 'COMPILED'
+    COMPILING = 'COMPILING'
     FAILED = 'FAILED'
     FINISHED = 'FINISHED'
     QUEUED = 'QUEUED'
     RUNNING = 'RUNNING'
+    STARTED = 'STARTED'
 
 
 @dataclass
@@ -2937,12 +4160,6 @@ class RestoreResponse:
 
 @dataclass
 class ResultData:
-    """Contains the result data of a single chunk when using `INLINE` disposition. When using
-    `EXTERNAL_LINKS` disposition, the array `external_links` is used instead to provide presigned
-    URLs to the result data in cloud storage. Exactly one of these alternatives is used. (While the
-    `external_links` array prepares the API to return multiple links in a single response. Currently
-    only a single link is returned.)"""
-
     byte_count: Optional[int] = None
     """The number of bytes in the result chunk. This field is not available when using `INLINE`
     disposition."""
@@ -3069,6 +4286,12 @@ class ResultSchema:
         return cls(column_count=d.get('column_count', None), columns=_repeated_dict(d, 'columns', ColumnInfo))
 
 
+class RunAsMode(Enum):
+
+    OWNER = 'OWNER'
+    VIEWER = 'VIEWER'
+
+
 class RunAsRole(Enum):
     """Sets the **Run as** role for the object. Must be set to one of `"viewer"` (signifying "run as
     viewer" behavior) or `"owner"` (signifying "run as owner" behavior)"""
@@ -3077,6 +4300,23 @@ class RunAsRole(Enum):
     VIEWER = 'viewer'
 
 
+@dataclass
+class ServerlessChannelInfo:
+    name: Optional[ChannelName] = None
+    """Name of the Channel"""
+
+    def as_dict(self) -> dict:
+        """Serializes the ServerlessChannelInfo into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.name is not None: body['name'] = self.name.value
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> ServerlessChannelInfo:
+        """Deserializes the ServerlessChannelInfo from a dictionary."""
+        return cls(name=_enum(d, 'name', ChannelName))
+
+
 @dataclass
 class ServiceError:
     error_code: Optional[ServiceErrorCode] = None
@@ -3273,8 +4513,10 @@ class StatementParameterListItem:
     type: Optional[str] = None
     """The data type, given as a string. For example: `INT`, `STRING`, `DECIMAL(10,2)`. If no type is
     given the type is assumed to be `STRING`. Complex types, such as `ARRAY`, `MAP`, and `STRUCT`
-    are not supported. For valid types, refer to the section [Data
-    types](/sql/language-manual/functions/cast.html) of the SQL language reference."""
+    are not supported. For valid types, refer to the section [Data types] of the SQL language
+    reference.
+    
+    [Data types]: https://docs.databricks.com/sql/language-manual/functions/cast.html"""
 
     value: Optional[str] = None
     """The value to substitute, represented as a string. If omitted, the value is interpreted as NULL."""
@@ -3293,6 +4535,38 @@ class StatementParameterListItem:
         return cls(name=d.get('name', None), type=d.get('type', None), value=d.get('value', None))
 
 
+@dataclass
+class StatementResponse:
+    manifest: Optional[ResultManifest] = None
+    """The result manifest provides schema and metadata for the result set."""
+
+    result: Optional[ResultData] = None
+
+    statement_id: Optional[str] = None
+    """The statement ID is returned upon successfully submitting a SQL statement, and is a required
+    reference for all subsequent calls."""
+
+    status: Optional[StatementStatus] = None
+    """The status response includes execution state and if relevant, error information."""
+
+    def as_dict(self) -> dict:
+        """Serializes the StatementResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.manifest: body['manifest'] = self.manifest.as_dict()
+        if self.result: body['result'] = self.result.as_dict()
+        if self.statement_id is not None: body['statement_id'] = self.statement_id
+        if self.status: body['status'] = self.status.as_dict()
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> StatementResponse:
+        """Deserializes the StatementResponse from a dictionary."""
+        return cls(manifest=_from_dict(d, 'manifest', ResultManifest),
+                   result=_from_dict(d, 'result', ResultData),
+                   statement_id=d.get('statement_id', None),
+                   status=_from_dict(d, 'status', StatementStatus))
+
+
 class StatementState(Enum):
     """Statement execution state: - `PENDING`: waiting for warehouse - `RUNNING`: running -
     `SUCCEEDED`: execution was successful, result data available for fetch - `FAILED`: execution
@@ -3492,19 +4766,35 @@ class TerminationReasonCode(Enum):
 class TerminationReasonType(Enum):
     """type of the termination"""
 
-    CLIENT_ERROR = 'CLIENT_ERROR'
-    CLOUD_FAILURE = 'CLOUD_FAILURE'
-    SERVICE_FAULT = 'SERVICE_FAULT'
-    SUCCESS = 'SUCCESS'
+    CLIENT_ERROR = 'CLIENT_ERROR'
+    CLOUD_FAILURE = 'CLOUD_FAILURE'
+    SERVICE_FAULT = 'SERVICE_FAULT'
+    SUCCESS = 'SUCCESS'
+
+
+@dataclass
+class TextValue:
+    value: Optional[str] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the TextValue into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.value is not None: body['value'] = self.value
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> TextValue:
+        """Deserializes the TextValue from a dictionary."""
+        return cls(value=d.get('value', None))
 
 
 @dataclass
 class TimeRange:
     end_time_ms: Optional[int] = None
-    """Limit results to queries that started before this time."""
+    """The end time in milliseconds."""
 
     start_time_ms: Optional[int] = None
-    """Limit results to queries that started after this time."""
+    """The start time in milliseconds."""
 
     def as_dict(self) -> dict:
         """Serializes the TimeRange into a dictionary suitable for use as a JSON request body."""
@@ -3536,6 +4826,179 @@ class TransferOwnershipObjectId:
         return cls(new_owner=d.get('new_owner', None))
 
 
+@dataclass
+class UpdateAlertRequest:
+    update_mask: str
+    """Field mask is required to be passed into the PATCH request. Field mask specifies which fields of
+    the setting payload will be updated. The field mask needs to be supplied as single string. To
+    specify multiple fields in the field mask, use comma as the separator (no space)."""
+
+    alert: Optional[UpdateAlertRequestAlert] = None
+
+    id: Optional[str] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the UpdateAlertRequest into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.alert: body['alert'] = self.alert.as_dict()
+        if self.id is not None: body['id'] = self.id
+        if self.update_mask is not None: body['update_mask'] = self.update_mask
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> UpdateAlertRequest:
+        """Deserializes the UpdateAlertRequest from a dictionary."""
+        return cls(alert=_from_dict(d, 'alert', UpdateAlertRequestAlert),
+                   id=d.get('id', None),
+                   update_mask=d.get('update_mask', None))
+
+
+@dataclass
+class UpdateAlertRequestAlert:
+    condition: Optional[AlertCondition] = None
+    """Trigger conditions of the alert."""
+
+    custom_body: Optional[str] = None
+    """Custom body of alert notification, if it exists. See [here] for custom templating instructions.
+    
+    [here]: https://docs.databricks.com/sql/user/alerts/index.html"""
+
+    custom_subject: Optional[str] = None
+    """Custom subject of alert notification, if it exists. This can include email subject entries and
+    Slack notification headers, for example. See [here] for custom templating instructions.
+    
+    [here]: https://docs.databricks.com/sql/user/alerts/index.html"""
+
+    display_name: Optional[str] = None
+    """The display name of the alert."""
+
+    owner_user_name: Optional[str] = None
+    """The owner's username. This field is set to "Unavailable" if the user has been deleted."""
+
+    query_id: Optional[str] = None
+    """UUID of the query attached to the alert."""
+
+    seconds_to_retrigger: Optional[int] = None
+    """Number of seconds an alert must wait after being triggered to rearm itself. After rearming, it
+    can be triggered again. If 0 or not specified, the alert will not be triggered again."""
+
+    def as_dict(self) -> dict:
+        """Serializes the UpdateAlertRequestAlert into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.condition: body['condition'] = self.condition.as_dict()
+        if self.custom_body is not None: body['custom_body'] = self.custom_body
+        if self.custom_subject is not None: body['custom_subject'] = self.custom_subject
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.owner_user_name is not None: body['owner_user_name'] = self.owner_user_name
+        if self.query_id is not None: body['query_id'] = self.query_id
+        if self.seconds_to_retrigger is not None: body['seconds_to_retrigger'] = self.seconds_to_retrigger
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> UpdateAlertRequestAlert:
+        """Deserializes the UpdateAlertRequestAlert from a dictionary."""
+        return cls(condition=_from_dict(d, 'condition', AlertCondition),
+                   custom_body=d.get('custom_body', None),
+                   custom_subject=d.get('custom_subject', None),
+                   display_name=d.get('display_name', None),
+                   owner_user_name=d.get('owner_user_name', None),
+                   query_id=d.get('query_id', None),
+                   seconds_to_retrigger=d.get('seconds_to_retrigger', None))
+
+
+@dataclass
+class UpdateQueryRequest:
+    update_mask: str
+    """Field mask is required to be passed into the PATCH request. Field mask specifies which fields of
+    the setting payload will be updated. The field mask needs to be supplied as single string. To
+    specify multiple fields in the field mask, use comma as the separator (no space)."""
+
+    id: Optional[str] = None
+
+    query: Optional[UpdateQueryRequestQuery] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the UpdateQueryRequest into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.id is not None: body['id'] = self.id
+        if self.query: body['query'] = self.query.as_dict()
+        if self.update_mask is not None: body['update_mask'] = self.update_mask
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> UpdateQueryRequest:
+        """Deserializes the UpdateQueryRequest from a dictionary."""
+        return cls(id=d.get('id', None),
+                   query=_from_dict(d, 'query', UpdateQueryRequestQuery),
+                   update_mask=d.get('update_mask', None))
+
+
+@dataclass
+class UpdateQueryRequestQuery:
+    apply_auto_limit: Optional[bool] = None
+    """Whether to apply a 1000 row limit to the query result."""
+
+    catalog: Optional[str] = None
+    """Name of the catalog where this query will be executed."""
+
+    description: Optional[str] = None
+    """General description that conveys additional information about this query such as usage notes."""
+
+    display_name: Optional[str] = None
+    """Display name of the query that appears in list views, widget headings, and on the query page."""
+
+    owner_user_name: Optional[str] = None
+    """Username of the user that owns the query."""
+
+    parameters: Optional[List[QueryParameter]] = None
+    """List of query parameter definitions."""
+
+    query_text: Optional[str] = None
+    """Text of the query to be run."""
+
+    run_as_mode: Optional[RunAsMode] = None
+    """Sets the "Run as" role for the object."""
+
+    schema: Optional[str] = None
+    """Name of the schema where this query will be executed."""
+
+    tags: Optional[List[str]] = None
+
+    warehouse_id: Optional[str] = None
+    """ID of the SQL warehouse attached to the query."""
+
+    def as_dict(self) -> dict:
+        """Serializes the UpdateQueryRequestQuery into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.apply_auto_limit is not None: body['apply_auto_limit'] = self.apply_auto_limit
+        if self.catalog is not None: body['catalog'] = self.catalog
+        if self.description is not None: body['description'] = self.description
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.owner_user_name is not None: body['owner_user_name'] = self.owner_user_name
+        if self.parameters: body['parameters'] = [v.as_dict() for v in self.parameters]
+        if self.query_text is not None: body['query_text'] = self.query_text
+        if self.run_as_mode is not None: body['run_as_mode'] = self.run_as_mode.value
+        if self.schema is not None: body['schema'] = self.schema
+        if self.tags: body['tags'] = [v for v in self.tags]
+        if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> UpdateQueryRequestQuery:
+        """Deserializes the UpdateQueryRequestQuery from a dictionary."""
+        return cls(apply_auto_limit=d.get('apply_auto_limit', None),
+                   catalog=d.get('catalog', None),
+                   description=d.get('description', None),
+                   display_name=d.get('display_name', None),
+                   owner_user_name=d.get('owner_user_name', None),
+                   parameters=_repeated_dict(d, 'parameters', QueryParameter),
+                   query_text=d.get('query_text', None),
+                   run_as_mode=_enum(d, 'run_as_mode', RunAsMode),
+                   schema=d.get('schema', None),
+                   tags=d.get('tags', None),
+                   warehouse_id=d.get('warehouse_id', None))
+
+
 @dataclass
 class UpdateResponse:
 
@@ -3550,6 +5013,67 @@ class UpdateResponse:
         return cls()
 
 
+@dataclass
+class UpdateVisualizationRequest:
+    update_mask: str
+    """Field mask is required to be passed into the PATCH request. Field mask specifies which fields of
+    the setting payload will be updated. The field mask needs to be supplied as single string. To
+    specify multiple fields in the field mask, use comma as the separator (no space)."""
+
+    id: Optional[str] = None
+
+    visualization: Optional[UpdateVisualizationRequestVisualization] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the UpdateVisualizationRequest into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.id is not None: body['id'] = self.id
+        if self.update_mask is not None: body['update_mask'] = self.update_mask
+        if self.visualization: body['visualization'] = self.visualization.as_dict()
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> UpdateVisualizationRequest:
+        """Deserializes the UpdateVisualizationRequest from a dictionary."""
+        return cls(id=d.get('id', None),
+                   update_mask=d.get('update_mask', None),
+                   visualization=_from_dict(d, 'visualization', UpdateVisualizationRequestVisualization))
+
+
+@dataclass
+class UpdateVisualizationRequestVisualization:
+    display_name: Optional[str] = None
+    """The display name of the visualization."""
+
+    serialized_options: Optional[str] = None
+    """The visualization options varies widely from one visualization type to the next and is
+    unsupported. Databricks does not recommend modifying visualization options directly."""
+
+    serialized_query_plan: Optional[str] = None
+    """The visualization query plan varies widely from one visualization type to the next and is
+    unsupported. Databricks does not recommend modifying the visualization query plan directly."""
+
+    type: Optional[str] = None
+    """The type of visualization: counter, table, funnel, and so on."""
+
+    def as_dict(self) -> dict:
+        """Serializes the UpdateVisualizationRequestVisualization into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.serialized_options is not None: body['serialized_options'] = self.serialized_options
+        if self.serialized_query_plan is not None: body['serialized_query_plan'] = self.serialized_query_plan
+        if self.type is not None: body['type'] = self.type
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> UpdateVisualizationRequestVisualization:
+        """Deserializes the UpdateVisualizationRequestVisualization from a dictionary."""
+        return cls(display_name=d.get('display_name', None),
+                   serialized_options=d.get('serialized_options', None),
+                   serialized_query_plan=d.get('serialized_query_plan', None),
+                   type=d.get('type', None))
+
+
 @dataclass
 class User:
     email: Optional[str] = None
@@ -3574,57 +5098,56 @@ class User:
 
 @dataclass
 class Visualization:
-    """The visualization description API changes frequently and is unsupported. You can duplicate a
-    visualization by copying description objects received _from the API_ and then using them to
-    create a new one with a POST request to the same endpoint. Databricks does not recommend
-    constructing ad-hoc visualizations entirely in JSON."""
+    create_time: Optional[str] = None
+    """The timestamp indicating when the visualization was created."""
 
-    created_at: Optional[str] = None
-
-    description: Optional[str] = None
-    """A short description of this visualization. This is not displayed in the UI."""
+    display_name: Optional[str] = None
+    """The display name of the visualization."""
 
     id: Optional[str] = None
-    """The UUID for this visualization."""
+    """UUID identifying the visualization."""
 
-    name: Optional[str] = None
-    """The name of the visualization that appears on dashboards and the query screen."""
+    query_id: Optional[str] = None
+    """UUID of the query that the visualization is attached to."""
 
-    options: Optional[Any] = None
-    """The options object varies widely from one visualization type to the next and is unsupported.
-    Databricks does not recommend modifying visualization settings in JSON."""
+    serialized_options: Optional[str] = None
+    """The visualization options varies widely from one visualization type to the next and is
+    unsupported. Databricks does not recommend modifying visualization options directly."""
 
-    query: Optional[Query] = None
+    serialized_query_plan: Optional[str] = None
+    """The visualization query plan varies widely from one visualization type to the next and is
+    unsupported. Databricks does not recommend modifying the visualization query plan directly."""
 
     type: Optional[str] = None
-    """The type of visualization: chart, table, pivot table, and so on."""
+    """The type of visualization: counter, table, funnel, and so on."""
 
-    updated_at: Optional[str] = None
+    update_time: Optional[str] = None
+    """The timestamp indicating when the visualization was updated."""
 
     def as_dict(self) -> dict:
         """Serializes the Visualization into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.created_at is not None: body['created_at'] = self.created_at
-        if self.description is not None: body['description'] = self.description
+        if self.create_time is not None: body['create_time'] = self.create_time
+        if self.display_name is not None: body['display_name'] = self.display_name
         if self.id is not None: body['id'] = self.id
-        if self.name is not None: body['name'] = self.name
-        if self.options: body['options'] = self.options
-        if self.query: body['query'] = self.query.as_dict()
+        if self.query_id is not None: body['query_id'] = self.query_id
+        if self.serialized_options is not None: body['serialized_options'] = self.serialized_options
+        if self.serialized_query_plan is not None: body['serialized_query_plan'] = self.serialized_query_plan
         if self.type is not None: body['type'] = self.type
-        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.update_time is not None: body['update_time'] = self.update_time
         return body
 
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> Visualization:
         """Deserializes the Visualization from a dictionary."""
-        return cls(created_at=d.get('created_at', None),
-                   description=d.get('description', None),
+        return cls(create_time=d.get('create_time', None),
+                   display_name=d.get('display_name', None),
                    id=d.get('id', None),
-                   name=d.get('name', None),
-                   options=d.get('options', None),
-                   query=_from_dict(d, 'query', Query),
+                   query_id=d.get('query_id', None),
+                   serialized_options=d.get('serialized_options', None),
+                   serialized_query_plan=d.get('serialized_query_plan', None),
                    type=d.get('type', None),
-                   updated_at=d.get('updated_at', None))
+                   update_time=d.get('update_time', None))
 
 
 @dataclass
@@ -3727,6 +5250,7 @@ class WarehousePermissionLevel(Enum):
     """Permission level"""
 
     CAN_MANAGE = 'CAN_MANAGE'
+    CAN_MONITOR = 'CAN_MONITOR'
     CAN_USE = 'CAN_USE'
     IS_OWNER = 'IS_OWNER'
 
@@ -3839,7 +5363,7 @@ class Widget:
 
     options: Optional[WidgetOptions] = None
 
-    visualization: Optional[Visualization] = None
+    visualization: Optional[LegacyVisualization] = None
     """The visualization description API changes frequently and is unsupported. You can duplicate a
     visualization by copying description objects received _from the API_ and then using them to
     create a new one with a POST request to the same endpoint. Databricks does not recommend
@@ -3862,7 +5386,7 @@ class Widget:
         """Deserializes the Widget from a dictionary."""
         return cls(id=d.get('id', None),
                    options=_from_dict(d, 'options', WidgetOptions),
-                   visualization=_from_dict(d, 'visualization', Visualization),
+                   visualization=_from_dict(d, 'visualization', LegacyVisualization),
                    width=d.get('width', None))
 
 
@@ -3929,37 +5453,150 @@ class WidgetPosition:
     row: Optional[int] = None
     """row in the dashboard grid. Values start with 0"""
 
-    size_x: Optional[int] = None
-    """width of the widget measured in dashboard grid cells"""
+    size_x: Optional[int] = None
+    """width of the widget measured in dashboard grid cells"""
+
+    size_y: Optional[int] = None
+    """height of the widget measured in dashboard grid cells"""
+
+    def as_dict(self) -> dict:
+        """Serializes the WidgetPosition into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.auto_height is not None: body['autoHeight'] = self.auto_height
+        if self.col is not None: body['col'] = self.col
+        if self.row is not None: body['row'] = self.row
+        if self.size_x is not None: body['sizeX'] = self.size_x
+        if self.size_y is not None: body['sizeY'] = self.size_y
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> WidgetPosition:
+        """Deserializes the WidgetPosition from a dictionary."""
+        return cls(auto_height=d.get('autoHeight', None),
+                   col=d.get('col', None),
+                   row=d.get('row', None),
+                   size_x=d.get('sizeX', None),
+                   size_y=d.get('sizeY', None))
+
+
+class AlertsAPI:
+    """The alerts API can be used to perform CRUD operations on alerts. An alert is a Databricks SQL object that
+    periodically runs a query, evaluates a condition of its result, and notifies one or more users and/or
+    notification destinations if the condition was met. Alerts can be scheduled using the `sql_task` type of
+    the Jobs API, e.g. :method:jobs/create."""
+
+    def __init__(self, api_client):
+        self._api = api_client
+
+    def create(self, *, alert: Optional[CreateAlertRequestAlert] = None) -> Alert:
+        """Create an alert.
+        
+        Creates an alert.
+        
+        :param alert: :class:`CreateAlertRequestAlert` (optional)
+        
+        :returns: :class:`Alert`
+        """
+        body = {}
+        if alert is not None: body['alert'] = alert.as_dict()
+        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
+
+        res = self._api.do('POST', '/api/2.0/sql/alerts', body=body, headers=headers)
+        return Alert.from_dict(res)
+
+    def delete(self, id: str):
+        """Delete an alert.
+        
+        Moves an alert to the trash. Trashed alerts immediately disappear from searches and list views, and
+        can no longer trigger. You can restore a trashed alert through the UI. A trashed alert is permanently
+        deleted after 30 days.
+        
+        :param id: str
+        
+        
+        """
+
+        headers = {'Accept': 'application/json', }
+
+        self._api.do('DELETE', f'/api/2.0/sql/alerts/{id}', headers=headers)
+
+    def get(self, id: str) -> Alert:
+        """Get an alert.
+        
+        Gets an alert.
+        
+        :param id: str
+        
+        :returns: :class:`Alert`
+        """
+
+        headers = {'Accept': 'application/json', }
+
+        res = self._api.do('GET', f'/api/2.0/sql/alerts/{id}', headers=headers)
+        return Alert.from_dict(res)
+
+    def list(self,
+             *,
+             page_size: Optional[int] = None,
+             page_token: Optional[str] = None) -> Iterator[ListAlertsResponseAlert]:
+        """List alerts.
+        
+        Gets a list of alerts accessible to the user, ordered by creation time. **Warning:** Calling this API
+        concurrently 10 or more times could result in throttling, service degradation, or a temporary ban.
+        
+        :param page_size: int (optional)
+        :param page_token: str (optional)
+        
+        :returns: Iterator over :class:`ListAlertsResponseAlert`
+        """
+
+        query = {}
+        if page_size is not None: query['page_size'] = page_size
+        if page_token is not None: query['page_token'] = page_token
+        headers = {'Accept': 'application/json', }
 
-    size_y: Optional[int] = None
-    """height of the widget measured in dashboard grid cells"""
+        while True:
+            json = self._api.do('GET', '/api/2.0/sql/alerts', query=query, headers=headers)
+            if 'results' in json:
+                for v in json['results']:
+                    yield ListAlertsResponseAlert.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 as_dict(self) -> dict:
-        """Serializes the WidgetPosition into a dictionary suitable for use as a JSON request body."""
+    def update(self, id: str, update_mask: str, *, alert: Optional[UpdateAlertRequestAlert] = None) -> Alert:
+        """Update an alert.
+        
+        Updates an alert.
+        
+        :param id: str
+        :param update_mask: str
+          Field mask is required to be passed into the PATCH request. Field mask specifies which fields of the
+          setting payload will be updated. The field mask needs to be supplied as single string. To specify
+          multiple fields in the field mask, use comma as the separator (no space).
+        :param alert: :class:`UpdateAlertRequestAlert` (optional)
+        
+        :returns: :class:`Alert`
+        """
         body = {}
-        if self.auto_height is not None: body['autoHeight'] = self.auto_height
-        if self.col is not None: body['col'] = self.col
-        if self.row is not None: body['row'] = self.row
-        if self.size_x is not None: body['sizeX'] = self.size_x
-        if self.size_y is not None: body['sizeY'] = self.size_y
-        return body
+        if alert is not None: body['alert'] = alert.as_dict()
+        if update_mask is not None: body['update_mask'] = update_mask
+        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> WidgetPosition:
-        """Deserializes the WidgetPosition from a dictionary."""
-        return cls(auto_height=d.get('autoHeight', None),
-                   col=d.get('col', None),
-                   row=d.get('row', None),
-                   size_x=d.get('sizeX', None),
-                   size_y=d.get('sizeY', None))
+        res = self._api.do('PATCH', f'/api/2.0/sql/alerts/{id}', body=body, headers=headers)
+        return Alert.from_dict(res)
 
 
-class AlertsAPI:
+class AlertsLegacyAPI:
     """The alerts API can be used to perform CRUD operations on alerts. An alert is a Databricks SQL object that
     periodically runs a query, evaluates a condition of its result, and notifies one or more users and/or
     notification destinations if the condition was met. Alerts can be scheduled using the `sql_task` type of
-    the Jobs API, e.g. :method:jobs/create."""
+    the Jobs API, e.g. :method:jobs/create.
+    
+    **Note**: A new version of the Databricks SQL API is now available. Please see the latest version. [Learn
+    more]
+    
+    [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html"""
 
     def __init__(self, api_client):
         self._api = api_client
@@ -3970,12 +5607,17 @@ class AlertsAPI:
                query_id: str,
                *,
                parent: Optional[str] = None,
-               rearm: Optional[int] = None) -> Alert:
+               rearm: Optional[int] = None) -> LegacyAlert:
         """Create an alert.
         
         Creates an alert. An alert is a Databricks SQL object that periodically runs a query, evaluates a
         condition of its result, and notifies users or notification destinations if the condition was met.
         
+        **Note**: A new version of the Databricks SQL API is now available. Please use :method:alerts/create
+        instead. [Learn more]
+        
+        [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
+        
         :param name: str
           Name of the alert.
         :param options: :class:`AlertOptions`
@@ -3988,7 +5630,7 @@ class AlertsAPI:
           Number of seconds after being triggered before the alert rearms itself and can be triggered again.
           If `null`, alert will never be triggered again.
         
-        :returns: :class:`Alert`
+        :returns: :class:`LegacyAlert`
         """
         body = {}
         if name is not None: body['name'] = name
@@ -3999,14 +5641,19 @@ class AlertsAPI:
         headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
         res = self._api.do('POST', '/api/2.0/preview/sql/alerts', body=body, headers=headers)
-        return Alert.from_dict(res)
+        return LegacyAlert.from_dict(res)
 
     def delete(self, alert_id: str):
         """Delete an alert.
         
-        Deletes an alert. Deleted alerts are no longer accessible and cannot be restored. **Note:** Unlike
+        Deletes an alert. Deleted alerts are no longer accessible and cannot be restored. **Note**: Unlike
         queries and dashboards, alerts cannot be moved to the trash.
         
+        **Note**: A new version of the Databricks SQL API is now available. Please use :method:alerts/delete
+        instead. [Learn more]
+        
+        [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
+        
         :param alert_id: str
         
         
@@ -4016,33 +5663,43 @@ class AlertsAPI:
 
         self._api.do('DELETE', f'/api/2.0/preview/sql/alerts/{alert_id}', headers=headers)
 
-    def get(self, alert_id: str) -> Alert:
+    def get(self, alert_id: str) -> LegacyAlert:
         """Get an alert.
         
         Gets an alert.
         
+        **Note**: A new version of the Databricks SQL API is now available. Please use :method:alerts/get
+        instead. [Learn more]
+        
+        [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
+        
         :param alert_id: str
         
-        :returns: :class:`Alert`
+        :returns: :class:`LegacyAlert`
         """
 
         headers = {'Accept': 'application/json', }
 
         res = self._api.do('GET', f'/api/2.0/preview/sql/alerts/{alert_id}', headers=headers)
-        return Alert.from_dict(res)
+        return LegacyAlert.from_dict(res)
 
-    def list(self) -> Iterator[Alert]:
+    def list(self) -> Iterator[LegacyAlert]:
         """Get alerts.
         
         Gets a list of alerts.
         
-        :returns: Iterator over :class:`Alert`
+        **Note**: A new version of the Databricks SQL API is now available. Please use :method:alerts/list
+        instead. [Learn more]
+        
+        [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
+        
+        :returns: Iterator over :class:`LegacyAlert`
         """
 
         headers = {'Accept': 'application/json', }
 
         res = self._api.do('GET', '/api/2.0/preview/sql/alerts', headers=headers)
-        return [Alert.from_dict(v) for v in res]
+        return [LegacyAlert.from_dict(v) for v in res]
 
     def update(self,
                alert_id: str,
@@ -4055,6 +5712,11 @@ class AlertsAPI:
         
         Updates an alert.
         
+        **Note**: A new version of the Databricks SQL API is now available. Please use :method:alerts/update
+        instead. [Learn more]
+        
+        [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
+        
         :param alert_id: str
         :param name: str
           Name of the alert.
@@ -4256,8 +5918,8 @@ class DashboardsAPI:
         
         Fetch a paginated list of dashboard objects.
         
-        ### **Warning: Calling this API concurrently 10 or more times could result in throttling, service
-        degradation, or a temporary ban.**
+        **Warning**: Calling this API concurrently 10 or more times could result in throttling, service
+        degradation, or a temporary ban.
         
         :param order: :class:`ListOrder` (optional)
           Name of dashboard attribute to order by.
@@ -4351,7 +6013,11 @@ class DataSourcesAPI:
     
     This API does not support searches. It returns the full list of SQL warehouses in your workspace. We
     advise you to use any text editor, REST client, or `grep` to search the response from this API for the
-    name of your SQL warehouse as it appears in Databricks SQL."""
+    name of your SQL warehouse as it appears in Databricks SQL.
+    
+    **Note**: A new version of the Databricks SQL API is now available. [Learn more]
+    
+    [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html"""
 
     def __init__(self, api_client):
         self._api = api_client
@@ -4363,6 +6029,11 @@ class DataSourcesAPI:
         API response are enumerated for clarity. However, you need only a SQL warehouse's `id` to create new
         queries against it.
         
+        **Note**: A new version of the Databricks SQL API is now available. Please use :method:warehouses/list
+        instead. [Learn more]
+        
+        [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
+        
         :returns: Iterator over :class:`DataSource`
         """
 
@@ -4383,7 +6054,11 @@ class DbsqlPermissionsAPI:
     
     - `CAN_RUN`: Allows read access and run access (superset of `CAN_VIEW`)
     
-    - `CAN_MANAGE`: Allows all actions: read, run, edit, delete, modify permissions (superset of `CAN_RUN`)"""
+    - `CAN_MANAGE`: Allows all actions: read, run, edit, delete, modify permissions (superset of `CAN_RUN`)
+    
+    **Note**: A new version of the Databricks SQL API is now available. [Learn more]
+    
+    [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html"""
 
     def __init__(self, api_client):
         self._api = api_client
@@ -4393,6 +6068,11 @@ class DbsqlPermissionsAPI:
         
         Gets a JSON representation of the access control list (ACL) for a specified object.
         
+        **Note**: A new version of the Databricks SQL API is now available. Please use
+        :method:workspace/getpermissions instead. [Learn more]
+        
+        [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
+        
         :param object_type: :class:`ObjectTypePlural`
           The type of object permissions to check.
         :param object_id: str
@@ -4418,6 +6098,11 @@ class DbsqlPermissionsAPI:
         Sets the access control list (ACL) for a specified object. This operation will complete rewrite the
         ACL.
         
+        **Note**: A new version of the Databricks SQL API is now available. Please use
+        :method:workspace/setpermissions instead. [Learn more]
+        
+        [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
+        
         :param object_type: :class:`ObjectTypePlural`
           The type of object permission to set.
         :param object_id: str
@@ -4446,6 +6131,11 @@ class DbsqlPermissionsAPI:
         
         Transfers ownership of a dashboard, query, or alert to an active user. Requires an admin API key.
         
+        **Note**: A new version of the Databricks SQL API is now available. For queries and alerts, please use
+        :method:queries/update and :method:alerts/update respectively instead. [Learn more]
+        
+        [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
+        
         :param object_type: :class:`OwnableObjectType`
           The type of object on which to change ownership.
         :param object_id: :class:`TransferOwnershipObjectId`
@@ -4467,9 +6157,154 @@ class DbsqlPermissionsAPI:
 
 
 class QueriesAPI:
+    """The queries API can be used to perform CRUD operations on queries. A query is a Databricks SQL object that
+    includes the target SQL warehouse, query text, name, description, tags, and parameters. Queries can be
+    scheduled using the `sql_task` type of the Jobs API, e.g. :method:jobs/create."""
+
+    def __init__(self, api_client):
+        self._api = api_client
+
+    def create(self, *, query: Optional[CreateQueryRequestQuery] = None) -> Query:
+        """Create a query.
+        
+        Creates a query.
+        
+        :param query: :class:`CreateQueryRequestQuery` (optional)
+        
+        :returns: :class:`Query`
+        """
+        body = {}
+        if query is not None: body['query'] = query.as_dict()
+        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
+
+        res = self._api.do('POST', '/api/2.0/sql/queries', body=body, headers=headers)
+        return Query.from_dict(res)
+
+    def delete(self, id: str):
+        """Delete a query.
+        
+        Moves a query to the trash. Trashed queries immediately disappear from searches and list views, and
+        cannot be used for alerts. You can restore a trashed query through the UI. A trashed query is
+        permanently deleted after 30 days.
+        
+        :param id: str
+        
+        
+        """
+
+        headers = {'Accept': 'application/json', }
+
+        self._api.do('DELETE', f'/api/2.0/sql/queries/{id}', headers=headers)
+
+    def get(self, id: str) -> Query:
+        """Get a query.
+        
+        Gets a query.
+        
+        :param id: str
+        
+        :returns: :class:`Query`
+        """
+
+        headers = {'Accept': 'application/json', }
+
+        res = self._api.do('GET', f'/api/2.0/sql/queries/{id}', headers=headers)
+        return Query.from_dict(res)
+
+    def list(self,
+             *,
+             page_size: Optional[int] = None,
+             page_token: Optional[str] = None) -> Iterator[ListQueryObjectsResponseQuery]:
+        """List queries.
+        
+        Gets a list of queries accessible to the user, ordered by creation time. **Warning:** Calling this API
+        concurrently 10 or more times could result in throttling, service degradation, or a temporary ban.
+        
+        :param page_size: int (optional)
+        :param page_token: str (optional)
+        
+        :returns: Iterator over :class:`ListQueryObjectsResponseQuery`
+        """
+
+        query = {}
+        if page_size is not None: query['page_size'] = page_size
+        if page_token is not None: query['page_token'] = page_token
+        headers = {'Accept': 'application/json', }
+
+        while True:
+            json = self._api.do('GET', '/api/2.0/sql/queries', query=query, headers=headers)
+            if 'results' in json:
+                for v in json['results']:
+                    yield ListQueryObjectsResponseQuery.from_dict(v)
+            if 'next_page_token' not in json or not json['next_page_token']:
+                return
+            query['page_token'] = json['next_page_token']
+
+    def list_visualizations(self,
+                            id: str,
+                            *,
+                            page_size: Optional[int] = None,
+                            page_token: Optional[str] = None) -> Iterator[Visualization]:
+        """List visualizations on a query.
+        
+        Gets a list of visualizations on a query.
+        
+        :param id: str
+        :param page_size: int (optional)
+        :param page_token: str (optional)
+        
+        :returns: Iterator over :class:`Visualization`
+        """
+
+        query = {}
+        if page_size is not None: query['page_size'] = page_size
+        if page_token is not None: query['page_token'] = page_token
+        headers = {'Accept': 'application/json', }
+
+        while True:
+            json = self._api.do('GET',
+                                f'/api/2.0/sql/queries/{id}/visualizations',
+                                query=query,
+                                headers=headers)
+            if 'results' in json:
+                for v in json['results']:
+                    yield Visualization.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, id: str, update_mask: str, *, query: Optional[UpdateQueryRequestQuery] = None) -> Query:
+        """Update a query.
+        
+        Updates a query.
+        
+        :param id: str
+        :param update_mask: str
+          Field mask is required to be passed into the PATCH request. Field mask specifies which fields of the
+          setting payload will be updated. The field mask needs to be supplied as single string. To specify
+          multiple fields in the field mask, use comma as the separator (no space).
+        :param query: :class:`UpdateQueryRequestQuery` (optional)
+        
+        :returns: :class:`Query`
+        """
+        body = {}
+        if query is not None: body['query'] = query.as_dict()
+        if update_mask is not None: body['update_mask'] = update_mask
+        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
+
+        res = self._api.do('PATCH', f'/api/2.0/sql/queries/{id}', body=body, headers=headers)
+        return Query.from_dict(res)
+
+
+class QueriesLegacyAPI:
     """These endpoints are used for CRUD operations on query definitions. Query definitions include the target
     SQL warehouse, query text, name, description, tags, parameters, and visualizations. Queries can be
-    scheduled using the `sql_task` type of the Jobs API, e.g. :method:jobs/create."""
+    scheduled using the `sql_task` type of the Jobs API, e.g. :method:jobs/create.
+    
+    **Note**: A new version of the Databricks SQL API is now available. Please see the latest version. [Learn
+    more]
+    
+    [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html"""
 
     def __init__(self, api_client):
         self._api = api_client
@@ -4483,7 +6318,7 @@ class QueriesAPI:
                parent: Optional[str] = None,
                query: Optional[str] = None,
                run_as_role: Optional[RunAsRole] = None,
-               tags: Optional[List[str]] = None) -> Query:
+               tags: Optional[List[str]] = None) -> LegacyQuery:
         """Create a new query definition.
         
         Creates a new query definition. Queries created with this endpoint belong to the authenticated user
@@ -4495,9 +6330,14 @@ class QueriesAPI:
         
         **Note**: You cannot add a visualization until you create the query.
         
+        **Note**: A new version of the Databricks SQL API is now available. Please use :method:queries/create
+        instead. [Learn more]
+        
+        [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
+        
         :param data_source_id: str (optional)
           Data source ID maps to the ID of the data source used by the resource and is distinct from the
-          warehouse ID. [Learn more].
+          warehouse ID. [Learn more]
           
           [Learn more]: https://docs.databricks.com/api/workspace/datasources/list
         :param description: str (optional)
@@ -4517,7 +6357,7 @@ class QueriesAPI:
           viewer" behavior) or `"owner"` (signifying "run as owner" behavior)
         :param tags: List[str] (optional)
         
-        :returns: :class:`Query`
+        :returns: :class:`LegacyQuery`
         """
         body = {}
         if data_source_id is not None: body['data_source_id'] = data_source_id
@@ -4531,7 +6371,7 @@ class QueriesAPI:
         headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
         res = self._api.do('POST', '/api/2.0/preview/sql/queries', body=body, headers=headers)
-        return Query.from_dict(res)
+        return LegacyQuery.from_dict(res)
 
     def delete(self, query_id: str):
         """Delete a query.
@@ -4539,6 +6379,11 @@ class QueriesAPI:
         Moves a query to the trash. Trashed queries immediately disappear from searches and list views, and
         they cannot be used for alerts. The trash is deleted after 30 days.
         
+        **Note**: A new version of the Databricks SQL API is now available. Please use :method:queries/delete
+        instead. [Learn more]
+        
+        [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
+        
         :param query_id: str
         
         
@@ -4548,34 +6393,44 @@ class QueriesAPI:
 
         self._api.do('DELETE', f'/api/2.0/preview/sql/queries/{query_id}', headers=headers)
 
-    def get(self, query_id: str) -> Query:
+    def get(self, query_id: str) -> LegacyQuery:
         """Get a query definition.
         
         Retrieve a query object definition along with contextual permissions information about the currently
         authenticated user.
         
+        **Note**: A new version of the Databricks SQL API is now available. Please use :method:queries/get
+        instead. [Learn more]
+        
+        [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
+        
         :param query_id: str
         
-        :returns: :class:`Query`
+        :returns: :class:`LegacyQuery`
         """
 
         headers = {'Accept': 'application/json', }
 
         res = self._api.do('GET', f'/api/2.0/preview/sql/queries/{query_id}', headers=headers)
-        return Query.from_dict(res)
+        return LegacyQuery.from_dict(res)
 
     def list(self,
              *,
              order: Optional[str] = None,
              page: Optional[int] = None,
              page_size: Optional[int] = None,
-             q: Optional[str] = None) -> Iterator[Query]:
+             q: Optional[str] = None) -> Iterator[LegacyQuery]:
         """Get a list of queries.
         
         Gets a list of queries. Optionally, this list can be filtered by a search term.
         
-        ### **Warning: Calling this API concurrently 10 or more times could result in throttling, service
-        degradation, or a temporary ban.**
+        **Warning**: Calling this API concurrently 10 or more times could result in throttling, service
+        degradation, or a temporary ban.
+        
+        **Note**: A new version of the Databricks SQL API is now available. Please use :method:queries/list
+        instead. [Learn more]
+        
+        [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
         
         :param order: str (optional)
           Name of query attribute to order by. Default sort order is ascending. Append a dash (`-`) to order
@@ -4598,7 +6453,7 @@ class QueriesAPI:
         :param q: str (optional)
           Full text search term
         
-        :returns: Iterator over :class:`Query`
+        :returns: Iterator over :class:`LegacyQuery`
         """
 
         query = {}
@@ -4619,7 +6474,7 @@ class QueriesAPI:
                     if i in seen:
                         continue
                     seen.add(i)
-                    yield Query.from_dict(v)
+                    yield LegacyQuery.from_dict(v)
             if 'results' not in json or not json['results']:
                 return
             query['page'] += 1
@@ -4630,6 +6485,11 @@ class QueriesAPI:
         Restore a query that has been moved to the trash. A restored query appears in list views and searches.
         You can use restored queries for alerts.
         
+        **Note**: A new version of the Databricks SQL API is now available. Please see the latest version.
+        [Learn more]
+        
+        [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
+        
         :param query_id: str
         
         
@@ -4648,17 +6508,22 @@ class QueriesAPI:
                options: Optional[Any] = None,
                query: Optional[str] = None,
                run_as_role: Optional[RunAsRole] = None,
-               tags: Optional[List[str]] = None) -> Query:
+               tags: Optional[List[str]] = None) -> LegacyQuery:
         """Change a query definition.
         
         Modify this query definition.
         
         **Note**: You cannot undo this operation.
         
+        **Note**: A new version of the Databricks SQL API is now available. Please use :method:queries/update
+        instead. [Learn more]
+        
+        [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
+        
         :param query_id: str
         :param data_source_id: str (optional)
           Data source ID maps to the ID of the data source used by the resource and is distinct from the
-          warehouse ID. [Learn more].
+          warehouse ID. [Learn more]
           
           [Learn more]: https://docs.databricks.com/api/workspace/datasources/list
         :param description: str (optional)
@@ -4676,7 +6541,7 @@ class QueriesAPI:
           viewer" behavior) or `"owner"` (signifying "run as owner" behavior)
         :param tags: List[str] (optional)
         
-        :returns: :class:`Query`
+        :returns: :class:`LegacyQuery`
         """
         body = {}
         if data_source_id is not None: body['data_source_id'] = data_source_id
@@ -4689,11 +6554,12 @@ class QueriesAPI:
         headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
         res = self._api.do('POST', f'/api/2.0/preview/sql/queries/{query_id}', body=body, headers=headers)
-        return Query.from_dict(res)
+        return LegacyQuery.from_dict(res)
 
 
 class QueryHistoryAPI:
-    """Access the history of queries through SQL warehouses."""
+    """A service responsible for storing and retrieving the list of queries run against SQL endpoints, serverless
+    compute, and DLT."""
 
     def __init__(self, api_client):
         self._api = api_client
@@ -4701,49 +6567,112 @@ class QueryHistoryAPI:
     def list(self,
              *,
              filter_by: Optional[QueryFilter] = None,
-             include_metrics: Optional[bool] = None,
              max_results: Optional[int] = None,
-             page_token: Optional[str] = None) -> Iterator[QueryInfo]:
+             page_token: Optional[str] = None) -> ListQueriesResponse:
         """List Queries.
         
-        List the history of queries through SQL warehouses.
+        List the history of queries through SQL warehouses, serverless compute, and DLT.
         
-        You can filter by user ID, warehouse ID, status, and time range.
+        You can filter by user ID, warehouse ID, status, and time range. Most recently started queries are
+        returned first (up to max_results in request). The pagination token returned in response can be used
+        to list subsequent query statuses.
         
         :param filter_by: :class:`QueryFilter` (optional)
           A filter to limit query history results. This field is optional.
-        :param include_metrics: bool (optional)
-          Whether to include metrics about query.
         :param max_results: int (optional)
-          Limit the number of results returned in one page. The default is 100.
+          Limit the number of results returned in one page. Must be less than 1000 and the default is 100.
         :param page_token: str (optional)
           A token that can be used to get the next page of results. The token can contains characters that
           need to be encoded before using it in a URL. For example, the character '+' needs to be replaced by
-          %2B.
+          %2B. This field is optional.
         
-        :returns: Iterator over :class:`QueryInfo`
+        :returns: :class:`ListQueriesResponse`
         """
 
         query = {}
         if filter_by is not None: query['filter_by'] = filter_by.as_dict()
-        if include_metrics is not None: query['include_metrics'] = include_metrics
         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', '/api/2.0/sql/history/queries', query=query, headers=headers)
-            if 'res' in json:
-                for v in json['res']:
-                    yield QueryInfo.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', '/api/2.0/sql/history/queries', query=query, headers=headers)
+        return ListQueriesResponse.from_dict(res)
 
 
 class QueryVisualizationsAPI:
+    """This is an evolving API that facilitates the addition and removal of visualizations from existing queries
+    in the Databricks Workspace. Data structures can change over time."""
+
+    def __init__(self, api_client):
+        self._api = api_client
+
+    def create(self,
+               *,
+               visualization: Optional[CreateVisualizationRequestVisualization] = None) -> Visualization:
+        """Add a visualization to a query.
+        
+        Adds a visualization to a query.
+        
+        :param visualization: :class:`CreateVisualizationRequestVisualization` (optional)
+        
+        :returns: :class:`Visualization`
+        """
+        body = {}
+        if visualization is not None: body['visualization'] = visualization.as_dict()
+        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
+
+        res = self._api.do('POST', '/api/2.0/sql/visualizations', body=body, headers=headers)
+        return Visualization.from_dict(res)
+
+    def delete(self, id: str):
+        """Remove a visualization.
+        
+        Removes a visualization.
+        
+        :param id: str
+        
+        
+        """
+
+        headers = {'Accept': 'application/json', }
+
+        self._api.do('DELETE', f'/api/2.0/sql/visualizations/{id}', headers=headers)
+
+    def update(self,
+               id: str,
+               update_mask: str,
+               *,
+               visualization: Optional[UpdateVisualizationRequestVisualization] = None) -> Visualization:
+        """Update a visualization.
+        
+        Updates a visualization.
+        
+        :param id: str
+        :param update_mask: str
+          Field mask is required to be passed into the PATCH request. Field mask specifies which fields of the
+          setting payload will be updated. The field mask needs to be supplied as single string. To specify
+          multiple fields in the field mask, use comma as the separator (no space).
+        :param visualization: :class:`UpdateVisualizationRequestVisualization` (optional)
+        
+        :returns: :class:`Visualization`
+        """
+        body = {}
+        if update_mask is not None: body['update_mask'] = update_mask
+        if visualization is not None: body['visualization'] = visualization.as_dict()
+        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
+
+        res = self._api.do('PATCH', f'/api/2.0/sql/visualizations/{id}', body=body, headers=headers)
+        return Visualization.from_dict(res)
+
+
+class QueryVisualizationsLegacyAPI:
     """This is an evolving API that facilitates the addition and removal of vizualisations from existing queries
-    within the Databricks Workspace. Data structures may change over time."""
+    within the Databricks Workspace. Data structures may change over time.
+    
+    **Note**: A new version of the Databricks SQL API is now available. Please see the latest version. [Learn
+    more]
+    
+    [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html"""
 
     def __init__(self, api_client):
         self._api = api_client
@@ -4754,9 +6683,16 @@ class QueryVisualizationsAPI:
                options: Any,
                *,
                description: Optional[str] = None,
-               name: Optional[str] = None) -> Visualization:
+               name: Optional[str] = None) -> LegacyVisualization:
         """Add visualization to a query.
         
+        Creates visualization in the query.
+        
+        **Note**: A new version of the Databricks SQL API is now available. Please use
+        :method:queryvisualizations/create instead. [Learn more]
+        
+        [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
+        
         :param query_id: str
           The identifier returned by :method:queries/create
         :param type: str
@@ -4769,7 +6705,7 @@ class QueryVisualizationsAPI:
         :param name: str (optional)
           The name of the visualization that appears on dashboards and the query screen.
         
-        :returns: :class:`Visualization`
+        :returns: :class:`LegacyVisualization`
         """
         body = {}
         if description is not None: body['description'] = description
@@ -4780,11 +6716,18 @@ class QueryVisualizationsAPI:
         headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
         res = self._api.do('POST', '/api/2.0/preview/sql/visualizations', body=body, headers=headers)
-        return Visualization.from_dict(res)
+        return LegacyVisualization.from_dict(res)
 
     def delete(self, id: str):
         """Remove visualization.
         
+        Removes a visualization from the query.
+        
+        **Note**: A new version of the Databricks SQL API is now available. Please use
+        :method:queryvisualizations/delete instead. [Learn more]
+        
+        [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
+        
         :param id: str
           Widget ID returned by :method:queryvizualisations/create
         
@@ -4802,11 +6745,18 @@ class QueryVisualizationsAPI:
                description: Optional[str] = None,
                name: Optional[str] = None,
                options: Optional[Any] = None,
-               query: Optional[Query] = None,
+               query: Optional[LegacyQuery] = None,
                type: Optional[str] = None,
-               updated_at: Optional[str] = None) -> Visualization:
+               updated_at: Optional[str] = None) -> LegacyVisualization:
         """Edit existing visualization.
         
+        Updates visualization in the query.
+        
+        **Note**: A new version of the Databricks SQL API is now available. Please use
+        :method:queryvisualizations/update instead. [Learn more]
+        
+        [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
+        
         :param id: str
           The UUID for this visualization.
         :param created_at: str (optional)
@@ -4817,12 +6767,12 @@ class QueryVisualizationsAPI:
         :param options: Any (optional)
           The options object varies widely from one visualization type to the next and is unsupported.
           Databricks does not recommend modifying visualization settings in JSON.
-        :param query: :class:`Query` (optional)
+        :param query: :class:`LegacyQuery` (optional)
         :param type: str (optional)
           The type of visualization: chart, table, pivot table, and so on.
         :param updated_at: str (optional)
         
-        :returns: :class:`Visualization`
+        :returns: :class:`LegacyVisualization`
         """
         body = {}
         if created_at is not None: body['created_at'] = created_at
@@ -4835,7 +6785,7 @@ class QueryVisualizationsAPI:
         headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
         res = self._api.do('POST', f'/api/2.0/preview/sql/visualizations/{id}', body=body, headers=headers)
-        return Visualization.from_dict(res)
+        return LegacyVisualization.from_dict(res)
 
 
 class StatementExecutionAPI:
@@ -4954,14 +6904,15 @@ class StatementExecutionAPI:
                           parameters: Optional[List[StatementParameterListItem]] = None,
                           row_limit: Optional[int] = None,
                           schema: Optional[str] = None,
-                          wait_timeout: Optional[str] = None) -> ExecuteStatementResponse:
+                          wait_timeout: Optional[str] = None) -> StatementResponse:
         """Execute a SQL statement.
         
         :param statement: str
           The SQL statement to execute. The statement can optionally be parameterized, see `parameters`.
         :param warehouse_id: str
-          Warehouse upon which to execute a statement. See also [What are SQL
-          warehouses?](/sql/admin/warehouse-type.html)
+          Warehouse upon which to execute a statement. See also [What are SQL warehouses?]
+          
+          [What are SQL warehouses?]: https://docs.databricks.com/sql/admin/warehouse-type.html
         :param byte_limit: int (optional)
           Applies the given byte limit to the statement's result size. Byte counts are based on internal data
           representations and might not match the final size in the requested `format`. If the result was
@@ -4973,26 +6924,6 @@ class StatementExecutionAPI:
           
           [`USE CATALOG`]: https://docs.databricks.com/sql/language-manual/sql-ref-syntax-ddl-use-catalog.html
         :param disposition: :class:`Disposition` (optional)
-          The fetch disposition provides two modes of fetching results: `INLINE` and `EXTERNAL_LINKS`.
-          
-          Statements executed with `INLINE` disposition will return result data inline, in `JSON_ARRAY`
-          format, in a series of chunks. If a given statement produces a result set with a size larger than 25
-          MiB, that statement execution is aborted, and no result set will be available.
-          
-          **NOTE** Byte limits are computed based upon internal representations of the result set data, and
-          might not match the sizes visible in JSON responses.
-          
-          Statements executed with `EXTERNAL_LINKS` disposition will return result data as external links:
-          URLs that point to cloud storage internal to the workspace. Using `EXTERNAL_LINKS` disposition
-          allows statements to generate arbitrarily sized result sets for fetching up to 100 GiB. The
-          resulting links have two important properties:
-          
-          1. They point to resources _external_ to the Databricks compute; therefore any associated
-          authentication information (typically a personal access token, OAuth token, or similar) _must be
-          removed_ when fetching from these links.
-          
-          2. These are presigned URLs with a specific expiration, indicated in the response. The behavior when
-          attempting to use an expired link is cloud specific.
         :param format: :class:`Format` (optional)
           Statement execution supports three result formats: `JSON_ARRAY` (default), `ARROW_STREAM`, and
           `CSV`.
@@ -5080,7 +7011,7 @@ class StatementExecutionAPI:
           the statement takes longer to execute, `on_wait_timeout` determines what should happen after the
           timeout is reached.
         
-        :returns: :class:`ExecuteStatementResponse`
+        :returns: :class:`StatementResponse`
         """
         body = {}
         if byte_limit is not None: body['byte_limit'] = byte_limit
@@ -5097,9 +7028,9 @@ class StatementExecutionAPI:
         headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
         res = self._api.do('POST', '/api/2.0/sql/statements/', body=body, headers=headers)
-        return ExecuteStatementResponse.from_dict(res)
+        return StatementResponse.from_dict(res)
 
-    def get_statement(self, statement_id: str) -> GetStatementResponse:
+    def get_statement(self, statement_id: str) -> StatementResponse:
         """Get status, manifest, and result first chunk.
         
         This request can be used to poll for the statement's status. When the `status.state` field is
@@ -5114,13 +7045,13 @@ class StatementExecutionAPI:
           The statement ID is returned upon successfully submitting a SQL statement, and is a required
           reference for all subsequent calls.
         
-        :returns: :class:`GetStatementResponse`
+        :returns: :class:`StatementResponse`
         """
 
         headers = {'Accept': 'application/json', }
 
         res = self._api.do('GET', f'/api/2.0/sql/statements/{statement_id}', headers=headers)
-        return GetStatementResponse.from_dict(res)
+        return StatementResponse.from_dict(res)
 
     def get_statement_result_chunk_n(self, statement_id: str, chunk_index: int) -> ResultData:
         """Get result chunk by index.