databricks-sdk 0.57.0__py3-none-any.whl → 0.59.0__py3-none-any.whl

databricks/sdk/service/sql.py

@@ -665,7 +665,9 @@ class AlertV2:
     """Text of the query to be run."""
 
     run_as_user_name: Optional[str] = None
-    """The run as username. This field is set to "Unavailable" if the user has been deleted."""
+    """The run as username or application ID of service principal. On Create and Update, this field can
+    be set to application ID of an active service principal. Setting this field requires the
+    servicePrincipal/user role."""
 
     schedule: Optional[CronSchedule] = None
 
@@ -1371,101 +1373,6 @@ class ComparisonOperator(Enum):
     NOT_EQUAL = "NOT_EQUAL"
 
 
-@dataclass
-class CreateAlert:
-    name: str
-    """Name of the alert."""
-
-    options: AlertOptions
-    """Alert configuration options."""
-
-    query_id: str
-    """Query ID."""
-
-    parent: Optional[str] = None
-    """The identifier of the workspace folder containing the object."""
-
-    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."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateAlert into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        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_id is not None:
-            body["query_id"] = self.query_id
-        if self.rearm is not None:
-            body["rearm"] = self.rearm
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateAlert into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.name is not None:
-            body["name"] = self.name
-        if self.options:
-            body["options"] = self.options
-        if self.parent is not None:
-            body["parent"] = self.parent
-        if self.query_id is not None:
-            body["query_id"] = self.query_id
-        if self.rearm is not None:
-            body["rearm"] = self.rearm
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateAlert:
-        """Deserializes the CreateAlert from a dictionary."""
-        return cls(
-            name=d.get("name", None),
-            options=_from_dict(d, "options", AlertOptions),
-            parent=d.get("parent", None),
-            query_id=d.get("query_id", None),
-            rearm=d.get("rearm", None),
-        )
-
-
-@dataclass
-class CreateAlertRequest:
-    alert: Optional[CreateAlertRequestAlert] = None
-
-    auto_resolve_display_name: Optional[bool] = None
-    """If true, automatically resolve alert display name conflicts. Otherwise, fail the request if the
-    alert's display name conflicts with an existing alert's display name."""
-
-    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()
-        if self.auto_resolve_display_name is not None:
-            body["auto_resolve_display_name"] = self.auto_resolve_display_name
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateAlertRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.alert:
-            body["alert"] = self.alert
-        if self.auto_resolve_display_name is not None:
-            body["auto_resolve_display_name"] = self.auto_resolve_display_name
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateAlertRequest:
-        """Deserializes the CreateAlertRequest from a dictionary."""
-        return cls(
-            alert=_from_dict(d, "alert", CreateAlertRequestAlert),
-            auto_resolve_display_name=d.get("auto_resolve_display_name", None),
-        )
-
-
 @dataclass
 class CreateAlertRequestAlert:
     condition: Optional[AlertCondition] = None
@@ -1555,41 +1462,6 @@ class CreateAlertRequestAlert:
         )
 
 
-@dataclass
-class CreateQueryRequest:
-    auto_resolve_display_name: Optional[bool] = None
-    """If true, automatically resolve query display name conflicts. Otherwise, fail the request if the
-    query's display name conflicts with an existing query's display name."""
-
-    query: Optional[CreateQueryRequestQuery] = None
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateQueryRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.auto_resolve_display_name is not None:
-            body["auto_resolve_display_name"] = self.auto_resolve_display_name
-        if self.query:
-            body["query"] = self.query.as_dict()
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateQueryRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.auto_resolve_display_name is not None:
-            body["auto_resolve_display_name"] = self.auto_resolve_display_name
-        if self.query:
-            body["query"] = self.query
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateQueryRequest:
-        """Deserializes the CreateQueryRequest from a dictionary."""
-        return cls(
-            auto_resolve_display_name=d.get("auto_resolve_display_name", None),
-            query=_from_dict(d, "query", CreateQueryRequestQuery),
-        )
-
-
 @dataclass
 class CreateQueryRequestQuery:
     apply_auto_limit: Optional[bool] = None
@@ -1696,92 +1568,6 @@ class CreateQueryRequestQuery:
         )
 
 
-@dataclass
-class CreateQueryVisualizationsLegacyRequest:
-    """Add visualization to a query"""
-
-    query_id: str
-    """The identifier returned by :method:queries/create"""
-
-    type: str
-    """The type of visualization: chart, table, pivot table, and so on."""
-
-    options: Any
-    """The options object varies widely from one visualization type to the next and is unsupported.
-    Databricks does not recommend modifying visualization settings in JSON."""
-
-    description: Optional[str] = None
-    """A short description of this visualization. This is not displayed in the UI."""
-
-    name: Optional[str] = None
-    """The name of the visualization that appears on dashboards and the query screen."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateQueryVisualizationsLegacyRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.description is not None:
-            body["description"] = self.description
-        if self.name is not None:
-            body["name"] = self.name
-        if self.options:
-            body["options"] = self.options
-        if self.query_id is not None:
-            body["query_id"] = self.query_id
-        if self.type is not None:
-            body["type"] = self.type
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateQueryVisualizationsLegacyRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.description is not None:
-            body["description"] = self.description
-        if self.name is not None:
-            body["name"] = self.name
-        if self.options:
-            body["options"] = self.options
-        if self.query_id is not None:
-            body["query_id"] = self.query_id
-        if self.type is not None:
-            body["type"] = self.type
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateQueryVisualizationsLegacyRequest:
-        """Deserializes the CreateQueryVisualizationsLegacyRequest from a dictionary."""
-        return cls(
-            description=d.get("description", None),
-            name=d.get("name", None),
-            options=d.get("options", None),
-            query_id=d.get("query_id", None),
-            type=d.get("type", 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
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateVisualizationRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.visualization:
-            body["visualization"] = self.visualization
-        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
@@ -1843,159 +1629,6 @@ class CreateVisualizationRequestVisualization:
         )
 
 
-@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 mins for serverless warehouses - Must be == 0 or >= 10 mins for
-    non-serverless warehouses - 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
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateWarehouseRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.auto_stop_mins is not None:
-            body["auto_stop_mins"] = self.auto_stop_mins
-        if self.channel:
-            body["channel"] = self.channel
-        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
-        if self.tags:
-            body["tags"] = self.tags
-        if self.warehouse_type is not None:
-            body["warehouse_type"] = self.warehouse_type
-        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),
-            enable_photon=d.get("enable_photon", None),
-            enable_serverless_compute=d.get("enable_serverless_compute", None),
-            instance_profile_arn=d.get("instance_profile_arn", None),
-            max_num_clusters=d.get("max_num_clusters", None),
-            min_num_clusters=d.get("min_num_clusters", None),
-            name=d.get("name", None),
-            spot_instance_policy=_enum(d, "spot_instance_policy", SpotInstancePolicy),
-            tags=_from_dict(d, "tags", EndpointTags),
-            warehouse_type=_enum(d, "warehouse_type", CreateWarehouseRequestWarehouseType),
-        )
-
-
 class CreateWarehouseRequestWarehouseType(Enum):
     """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`."""
@@ -2025,76 +1658,9 @@ class CreateWarehouseResponse:
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateWarehouseResponse:
-        """Deserializes the CreateWarehouseResponse from a dictionary."""
-        return cls(id=d.get("id", None))
-
-
-@dataclass
-class CreateWidget:
-    dashboard_id: str
-    """Dashboard ID returned by :method:dashboards/create."""
-
-    options: WidgetOptions
-
-    width: int
-    """Width of a widget"""
-
-    id: Optional[str] = None
-    """Widget ID returned by :method:dashboardwidgets/create"""
-
-    text: Optional[str] = None
-    """If this is a textbox widget, the application displays this text. This field is ignored if the
-    widget contains a visualization in the `visualization` field."""
-
-    visualization_id: Optional[str] = None
-    """Query Vizualization ID returned by :method:queryvisualizations/create."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateWidget into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.dashboard_id is not None:
-            body["dashboard_id"] = self.dashboard_id
-        if self.id is not None:
-            body["id"] = self.id
-        if self.options:
-            body["options"] = self.options.as_dict()
-        if self.text is not None:
-            body["text"] = self.text
-        if self.visualization_id is not None:
-            body["visualization_id"] = self.visualization_id
-        if self.width is not None:
-            body["width"] = self.width
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateWidget into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.dashboard_id is not None:
-            body["dashboard_id"] = self.dashboard_id
-        if self.id is not None:
-            body["id"] = self.id
-        if self.options:
-            body["options"] = self.options
-        if self.text is not None:
-            body["text"] = self.text
-        if self.visualization_id is not None:
-            body["visualization_id"] = self.visualization_id
-        if self.width is not None:
-            body["width"] = self.width
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateWidget:
-        """Deserializes the CreateWidget from a dictionary."""
-        return cls(
-            dashboard_id=d.get("dashboard_id", None),
-            id=d.get("id", None),
-            options=_from_dict(d, "options", WidgetOptions),
-            text=d.get("text", None),
-            visualization_id=d.get("visualization_id", None),
-            width=d.get("width", None),
-        )
+    def from_dict(cls, d: Dict[str, Any]) -> CreateWarehouseResponse:
+        """Deserializes the CreateWarehouseResponse from a dictionary."""
+        return cls(id=d.get("id", None))
 
 
 @dataclass
@@ -2304,56 +1870,6 @@ class Dashboard:
         )
 
 
-@dataclass
-class DashboardEditContent:
-    dashboard_id: Optional[str] = None
-
-    name: Optional[str] = None
-    """The title of this dashboard that appears in list views and at the top of the dashboard page."""
-
-    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
-
-    def as_dict(self) -> dict:
-        """Serializes the DashboardEditContent into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.dashboard_id is not None:
-            body["dashboard_id"] = self.dashboard_id
-        if self.name is not None:
-            body["name"] = self.name
-        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]
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DashboardEditContent into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.dashboard_id is not None:
-            body["dashboard_id"] = self.dashboard_id
-        if self.name is not None:
-            body["name"] = self.name
-        if self.run_as_role is not None:
-            body["run_as_role"] = self.run_as_role
-        if self.tags:
-            body["tags"] = self.tags
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DashboardEditContent:
-        """Deserializes the DashboardEditContent from a dictionary."""
-        return cls(
-            dashboard_id=d.get("dashboard_id", None),
-            name=d.get("name", None),
-            run_as_role=_enum(d, "run_as_role", RunAsRole),
-            tags=d.get("tags", None),
-        )
-
-
 @dataclass
 class DashboardOptions:
     moved_to_trash_at: Optional[str] = None
@@ -2380,73 +1896,6 @@ class DashboardOptions:
         return cls(moved_to_trash_at=d.get("moved_to_trash_at", None))
 
 
-@dataclass
-class DashboardPostContent:
-    name: str
-    """The title of this dashboard that appears in list views and at the top of the dashboard page."""
-
-    dashboard_filters_enabled: Optional[bool] = None
-    """Indicates whether the dashboard filters are enabled"""
-
-    is_favorite: Optional[bool] = None
-    """Indicates whether this dashboard object should appear in the current user's favorites list."""
-
-    parent: Optional[str] = None
-    """The identifier of the workspace folder containing the object."""
-
-    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
-
-    def as_dict(self) -> dict:
-        """Serializes the DashboardPostContent into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.dashboard_filters_enabled is not None:
-            body["dashboard_filters_enabled"] = self.dashboard_filters_enabled
-        if self.is_favorite is not None:
-            body["is_favorite"] = self.is_favorite
-        if self.name is not None:
-            body["name"] = self.name
-        if self.parent is not None:
-            body["parent"] = self.parent
-        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]
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DashboardPostContent into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.dashboard_filters_enabled is not None:
-            body["dashboard_filters_enabled"] = self.dashboard_filters_enabled
-        if self.is_favorite is not None:
-            body["is_favorite"] = self.is_favorite
-        if self.name is not None:
-            body["name"] = self.name
-        if self.parent is not None:
-            body["parent"] = self.parent
-        if self.run_as_role is not None:
-            body["run_as_role"] = self.run_as_role
-        if self.tags:
-            body["tags"] = self.tags
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DashboardPostContent:
-        """Deserializes the DashboardPostContent from a dictionary."""
-        return cls(
-            dashboard_filters_enabled=d.get("dashboard_filters_enabled", None),
-            is_favorite=d.get("is_favorite", None),
-            name=d.get("name", None),
-            parent=d.get("parent", None),
-            run_as_role=_enum(d, "run_as_role", RunAsRole),
-            tags=d.get("tags", None),
-        )
-
-
 @dataclass
 class DataSource:
     """A JSON object representing a DBSQL data source / SQL warehouse."""
@@ -2710,258 +2159,39 @@ class DeleteResponse:
         body = {}
         return body
 
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DeleteResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DeleteResponse:
-        """Deserializes the DeleteResponse from a dictionary."""
-        return cls()
-
-
-@dataclass
-class DeleteWarehouseResponse:
-    def as_dict(self) -> dict:
-        """Serializes the DeleteWarehouseResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DeleteWarehouseResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DeleteWarehouseResponse:
-        """Deserializes the DeleteWarehouseResponse from a dictionary."""
-        return cls()
-
-
-class Disposition(Enum):
-
-    EXTERNAL_LINKS = "EXTERNAL_LINKS"
-    INLINE = "INLINE"
-
-
-@dataclass
-class EditAlert:
-    name: str
-    """Name of the alert."""
-
-    options: AlertOptions
-    """Alert configuration options."""
-
-    query_id: str
-    """Query ID."""
-
-    alert_id: Optional[str] = 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."""
-
-    def as_dict(self) -> dict:
-        """Serializes the EditAlert 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.name is not None:
-            body["name"] = self.name
-        if self.options:
-            body["options"] = self.options.as_dict()
-        if self.query_id is not None:
-            body["query_id"] = self.query_id
-        if self.rearm is not None:
-            body["rearm"] = self.rearm
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the EditAlert into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.alert_id is not None:
-            body["alert_id"] = self.alert_id
-        if self.name is not None:
-            body["name"] = self.name
-        if self.options:
-            body["options"] = self.options
-        if self.query_id is not None:
-            body["query_id"] = self.query_id
-        if self.rearm is not None:
-            body["rearm"] = self.rearm
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> EditAlert:
-        """Deserializes the EditAlert from a dictionary."""
-        return cls(
-            alert_id=d.get("alert_id", None),
-            name=d.get("name", None),
-            options=_from_dict(d, "options", AlertOptions),
-            query_id=d.get("query_id", None),
-            rearm=d.get("rearm", None),
-        )
-
-
-@dataclass
-class EditWarehouseRequest:
-    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."""
-
-    id: Optional[str] = None
-    """Required. Id of the warehouse to configure."""
-
-    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."""
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeleteResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        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]) -> DeleteResponse:
+        """Deserializes the DeleteResponse from a dictionary."""
+        return cls()
 
-    warehouse_type: Optional[EditWarehouseRequestWarehouseType] = 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 DeleteWarehouseResponse:
     def as_dict(self) -> dict:
-        """Serializes the EditWarehouseRequest into a dictionary suitable for use as a JSON request body."""
+        """Serializes the DeleteWarehouseResponse 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.id is not None:
-            body["id"] = self.id
-        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
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the EditWarehouseRequest into a shallow dictionary of its immediate attributes."""
+        """Serializes the DeleteWarehouseResponse into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.auto_stop_mins is not None:
-            body["auto_stop_mins"] = self.auto_stop_mins
-        if self.channel:
-            body["channel"] = self.channel
-        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.id is not None:
-            body["id"] = self.id
-        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
-        if self.tags:
-            body["tags"] = self.tags
-        if self.warehouse_type is not None:
-            body["warehouse_type"] = self.warehouse_type
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> EditWarehouseRequest:
-        """Deserializes the EditWarehouseRequest 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),
-            enable_photon=d.get("enable_photon", None),
-            enable_serverless_compute=d.get("enable_serverless_compute", None),
-            id=d.get("id", None),
-            instance_profile_arn=d.get("instance_profile_arn", None),
-            max_num_clusters=d.get("max_num_clusters", None),
-            min_num_clusters=d.get("min_num_clusters", None),
-            name=d.get("name", None),
-            spot_instance_policy=_enum(d, "spot_instance_policy", SpotInstancePolicy),
-            tags=_from_dict(d, "tags", EndpointTags),
-            warehouse_type=_enum(d, "warehouse_type", EditWarehouseRequestWarehouseType),
-        )
+    def from_dict(cls, d: Dict[str, Any]) -> DeleteWarehouseResponse:
+        """Deserializes the DeleteWarehouseResponse from a dictionary."""
+        return cls()
+
+
+class Disposition(Enum):
+
+    EXTERNAL_LINKS = "EXTERNAL_LINKS"
+    INLINE = "INLINE"
 
 
 class EditWarehouseRequestWarehouseType(Enum):
@@ -3055,7 +2285,6 @@ class EndpointHealth:
     """Deprecated. split into summary and details for security"""
 
     status: Optional[Status] = None
-    """Health status of the warehouse."""
 
     summary: Optional[str] = None
     """A short summary of the health status in case of degraded/failed warehouses."""
@@ -3178,10 +2407,8 @@ class EndpointInfo:
     """ODBC parameters for the SQL warehouse"""
 
     spot_instance_policy: Optional[SpotInstancePolicy] = None
-    """Configurations whether the warehouse should use spot instances."""
 
     state: Optional[State] = None
-    """State of the warehouse"""
 
     tags: Optional[EndpointTags] = None
     """A set of key-value pairs that will be tagged on all resources (e.g., AWS instances and EBS
@@ -3416,195 +2643,6 @@ class EnumValue:
         )
 
 
-@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?]
-    
-    [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
-    data representations and might not match the final size in the requested `format`. If the result
-    was truncated due to the byte limit, then `truncated` in the response is set to `true`. When
-    using `EXTERNAL_LINKS` disposition, a default `byte_limit` of 100 GiB is applied if `byte_limit`
-    is not explcitly set."""
-
-    catalog: Optional[str] = None
-    """Sets default catalog for statement execution, similar to [`USE CATALOG`] in SQL.
-    
-    [`USE CATALOG`]: https://docs.databricks.com/sql/language-manual/sql-ref-syntax-ddl-use-catalog.html"""
-
-    disposition: Optional[Disposition] = None
-
-    format: Optional[Format] = None
-    """Statement execution supports three result formats: `JSON_ARRAY` (default), `ARROW_STREAM`, and
-    `CSV`.
-    
-    Important: The formats `ARROW_STREAM` and `CSV` are supported only with `EXTERNAL_LINKS`
-    disposition. `JSON_ARRAY` is supported in `INLINE` and `EXTERNAL_LINKS` disposition.
-    
-    When specifying `format=JSON_ARRAY`, result data will be formatted as an array of arrays of
-    values, where each value is either the *string representation* of a value, or `null`. For
-    example, the output of `SELECT concat('id-', id) AS strCol, id AS intCol, null AS nullCol FROM
-    range(3)` would look like this:
-    
-    ``` [ [ "id-1", "1", null ], [ "id-2", "2", null ], [ "id-3", "3", null ], ] ```
-    
-    When specifying `format=JSON_ARRAY` and `disposition=EXTERNAL_LINKS`, each chunk in the result
-    contains compact JSON with no indentation or extra whitespace.
-    
-    When specifying `format=ARROW_STREAM` and `disposition=EXTERNAL_LINKS`, each chunk in the result
-    will be formatted as Apache Arrow Stream. See the [Apache Arrow streaming format].
-    
-    When specifying `format=CSV` and `disposition=EXTERNAL_LINKS`, each chunk in the result will be
-    a CSV according to [RFC 4180] standard. All the columns values will have *string representation*
-    similar to the `JSON_ARRAY` format, and `null` values will be encoded as “null”. Only the
-    first chunk in the result would contain a header row with column names. For example, the output
-    of `SELECT concat('id-', id) AS strCol, id AS intCol, null as nullCol FROM range(3)` would look
-    like this:
-    
-    ``` strCol,intCol,nullCol id-1,1,null id-2,2,null id-3,3,null ```
-    
-    [Apache Arrow streaming format]: https://arrow.apache.org/docs/format/Columnar.html#ipc-streaming-format
-    [RFC 4180]: https://www.rfc-editor.org/rfc/rfc4180"""
-
-    on_wait_timeout: Optional[ExecuteStatementRequestOnWaitTimeout] = None
-    """When `wait_timeout > 0s`, the call will block up to the specified time. If the statement
-    execution doesn't finish within this time, `on_wait_timeout` determines whether the execution
-    should continue or be canceled. When set to `CONTINUE`, the statement execution continues
-    asynchronously and the call returns a statement ID which can be used for polling with
-    :method:statementexecution/getStatement. When set to `CANCEL`, the statement execution is
-    canceled and the call returns with a `CANCELED` state."""
-
-    parameters: Optional[List[StatementParameterListItem]] = None
-    """A list of parameters to pass into a SQL statement containing parameter markers. A parameter
-    consists of a name, a value, and optionally a type. To represent a NULL value, the `value` field
-    may be omitted or set to `null` explicitly. If the `type` field is omitted, the value is
-    interpreted as a string.
-    
-    If the type is given, parameters will be checked for type correctness according to the given
-    type. A value is correct if the provided string can be converted to the requested type using the
-    `cast` function. The exact semantics are described in the section [`cast` function] of the SQL
-    language reference.
-    
-    For example, the following statement contains two parameters, `my_name` and `my_date`:
-    
-    SELECT * FROM my_table WHERE name = :my_name AND date = :my_date
-    
-    The parameters can be passed in the request body as follows:
-    
-    { ..., "statement": "SELECT * FROM my_table WHERE name = :my_name AND date = :my_date",
-    "parameters": [ { "name": "my_name", "value": "the name" }, { "name": "my_date", "value":
-    "2020-01-01", "type": "DATE" } ] }
-    
-    Currently, positional parameters denoted by a `?` marker are not supported by the Databricks SQL
-    Statement Execution API.
-    
-    Also see the section [Parameter markers] of the SQL language reference.
-    
-    [Parameter markers]: https://docs.databricks.com/sql/language-manual/sql-ref-parameter-marker.html
-    [`cast` function]: https://docs.databricks.com/sql/language-manual/functions/cast.html"""
-
-    row_limit: Optional[int] = None
-    """Applies the given row limit to the statement's result set, but unlike the `LIMIT` clause in SQL,
-    it also sets the `truncated` field in the response to indicate whether the result was trimmed
-    due to the limit or not."""
-
-    schema: Optional[str] = None
-    """Sets default schema for statement execution, similar to [`USE SCHEMA`] in SQL.
-    
-    [`USE SCHEMA`]: https://docs.databricks.com/sql/language-manual/sql-ref-syntax-ddl-use-schema.html"""
-
-    wait_timeout: Optional[str] = None
-    """The time in seconds the call will wait for the statement's result set as `Ns`, where `N` can be
-    set to 0 or to a value between 5 and 50.
-    
-    When set to `0s`, the statement will execute in asynchronous mode and the call will not wait for
-    the execution to finish. In this case, the call returns directly with `PENDING` state and a
-    statement ID which can be used for polling with :method:statementexecution/getStatement.
-    
-    When set between 5 and 50 seconds, the call will behave synchronously up to this timeout and
-    wait for the statement execution to finish. If the execution finishes within this time, the call
-    returns immediately with a manifest and result data (or a `FAILED` state in case of an execution
-    error). If the statement takes longer to execute, `on_wait_timeout` determines what should
-    happen after the timeout is reached."""
-
-    def as_dict(self) -> dict:
-        """Serializes the ExecuteStatementRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.byte_limit is not None:
-            body["byte_limit"] = self.byte_limit
-        if self.catalog is not None:
-            body["catalog"] = self.catalog
-        if self.disposition is not None:
-            body["disposition"] = self.disposition.value
-        if self.format is not None:
-            body["format"] = self.format.value
-        if self.on_wait_timeout is not None:
-            body["on_wait_timeout"] = self.on_wait_timeout.value
-        if self.parameters:
-            body["parameters"] = [v.as_dict() for v in self.parameters]
-        if self.row_limit is not None:
-            body["row_limit"] = self.row_limit
-        if self.schema is not None:
-            body["schema"] = self.schema
-        if self.statement is not None:
-            body["statement"] = self.statement
-        if self.wait_timeout is not None:
-            body["wait_timeout"] = self.wait_timeout
-        if self.warehouse_id is not None:
-            body["warehouse_id"] = self.warehouse_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the ExecuteStatementRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.byte_limit is not None:
-            body["byte_limit"] = self.byte_limit
-        if self.catalog is not None:
-            body["catalog"] = self.catalog
-        if self.disposition is not None:
-            body["disposition"] = self.disposition
-        if self.format is not None:
-            body["format"] = self.format
-        if self.on_wait_timeout is not None:
-            body["on_wait_timeout"] = self.on_wait_timeout
-        if self.parameters:
-            body["parameters"] = self.parameters
-        if self.row_limit is not None:
-            body["row_limit"] = self.row_limit
-        if self.schema is not None:
-            body["schema"] = self.schema
-        if self.statement is not None:
-            body["statement"] = self.statement
-        if self.wait_timeout is not None:
-            body["wait_timeout"] = self.wait_timeout
-        if self.warehouse_id is not None:
-            body["warehouse_id"] = self.warehouse_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> ExecuteStatementRequest:
-        """Deserializes the ExecuteStatementRequest from a dictionary."""
-        return cls(
-            byte_limit=d.get("byte_limit", None),
-            catalog=d.get("catalog", None),
-            disposition=_enum(d, "disposition", Disposition),
-            format=_enum(d, "format", Format),
-            on_wait_timeout=_enum(d, "on_wait_timeout", ExecuteStatementRequestOnWaitTimeout),
-            parameters=_repeated_dict(d, "parameters", StatementParameterListItem),
-            row_limit=d.get("row_limit", None),
-            schema=d.get("schema", None),
-            statement=d.get("statement", None),
-            wait_timeout=d.get("wait_timeout", None),
-            warehouse_id=d.get("warehouse_id", None),
-        )
-
-
 class ExecuteStatementRequestOnWaitTimeout(Enum):
     """When `wait_timeout > 0s`, the call will block up to the specified time. If the statement
     execution doesn't finish within this time, `on_wait_timeout` determines whether the execution
@@ -3983,10 +3021,8 @@ class GetWarehouseResponse:
     """ODBC parameters for the SQL warehouse"""
 
     spot_instance_policy: Optional[SpotInstancePolicy] = None
-    """Configurations whether the warehouse should use spot instances."""
 
     state: Optional[State] = None
-    """State of the warehouse"""
 
     tags: Optional[EndpointTags] = None
     """A set of key-value pairs that will be tagged on all resources (e.g., AWS instances and EBS
@@ -3995,8 +3031,6 @@ class GetWarehouseResponse:
     Supported values: - Number of tags < 45."""
 
     warehouse_type: Optional[GetWarehouseResponseWarehouseType] = 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 GetWarehouseResponse into a dictionary suitable for use as a JSON request body."""
@@ -4336,8 +3370,6 @@ class LegacyAlert:
 
 
 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"
@@ -5317,7 +4349,6 @@ class OdbcParams:
 
 
 class OwnableObjectType(Enum):
-    """The singular form of the type of object which can be owned."""
 
     ALERT = "alert"
     DASHBOARD = "dashboard"
@@ -5402,7 +4433,6 @@ class Parameter:
 
 
 class ParameterType(Enum):
-    """Parameters can have several different types."""
 
     DATETIME = "datetime"
     ENUM = "enum"
@@ -5575,144 +4605,57 @@ class Query:
             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),
-            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
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the QueryBackedValue into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.multi_values_options:
-            body["multi_values_options"] = self.multi_values_options
-        if self.query_id is not None:
-            body["query_id"] = self.query_id
-        if self.values:
-            body["values"] = 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]
-    
-    [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."""
-
-    name: Optional[str] = None
-    """The title of this query that appears in list views, widget headings, and on the query page."""
+            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),
+            update_time=d.get("update_time", None),
+            warehouse_id=d.get("warehouse_id", None),
+        )
 
-    options: Optional[Any] = None
-    """Exclusively used for storing a list parameter definitions. A parameter is an object with
-    `title`, `name`, `type`, and `value` properties. The `value` field here is the default value. It
-    can be overridden at runtime."""
 
-    query: Optional[str] = None
-    """The text of the query to be run."""
+@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."""
 
-    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
+    values: Optional[List[str]] = None
+    """List of selected query parameter values."""
 
     def as_dict(self) -> dict:
-        """Serializes the QueryEditContent into a dictionary suitable for use as a JSON request body."""
+        """Serializes the QueryBackedValue into a dictionary suitable for use as a JSON request body."""
         body = {}
-        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.name is not None:
-            body["name"] = self.name
-        if self.options:
-            body["options"] = self.options
-        if self.query is not None:
-            body["query"] = self.query
+        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.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.values:
+            body["values"] = [v for v in self.values]
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the QueryEditContent into a shallow dictionary of its immediate attributes."""
+        """Serializes the QueryBackedValue into a shallow dictionary of its immediate attributes."""
         body = {}
-        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.name is not None:
-            body["name"] = self.name
-        if self.options:
-            body["options"] = self.options
-        if self.query is not None:
-            body["query"] = self.query
+        if self.multi_values_options:
+            body["multi_values_options"] = self.multi_values_options
         if self.query_id is not None:
             body["query_id"] = self.query_id
-        if self.run_as_role is not None:
-            body["run_as_role"] = self.run_as_role
-        if self.tags:
-            body["tags"] = self.tags
+        if self.values:
+            body["values"] = self.values
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> QueryEditContent:
-        """Deserializes the QueryEditContent from a dictionary."""
+    def from_dict(cls, d: Dict[str, Any]) -> QueryBackedValue:
+        """Deserializes the QueryBackedValue from a dictionary."""
         return cls(
-            data_source_id=d.get("data_source_id", None),
-            description=d.get("description", None),
-            name=d.get("name", None),
-            options=d.get("options", None),
-            query=d.get("query", None),
+            multi_values_options=_from_dict(d, "multi_values_options", MultiValuesOptions),
             query_id=d.get("query_id", None),
-            run_as_role=_enum(d, "run_as_role", RunAsRole),
-            tags=d.get("tags", None),
+            values=d.get("values", None),
         )
 
 
@@ -6071,6 +5014,9 @@ class QueryMetrics:
     photon_total_time_ms: Optional[int] = None
     """Total execution time for all individual Photon query engine tasks in the query, in milliseconds."""
 
+    projected_remaining_task_total_time_ms: Optional[int] = None
+    """projected remaining work to be done aggregated across all stages in the query, in milliseconds"""
+
     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
@@ -6100,6 +5046,10 @@ class QueryMetrics:
     read_remote_bytes: Optional[int] = None
     """Size of persistent data read from cloud object storage on your cloud tenant, in bytes."""
 
+    remaining_task_count: Optional[int] = None
+    """number of remaining tasks to complete this is based on the current status and could be bigger or
+    smaller in the future based on future updates"""
+
     result_fetch_time_ms: Optional[int] = None
     """Time spent fetching the query results after the execution finished, in milliseconds."""
 
@@ -6112,6 +5062,10 @@ class QueryMetrics:
     rows_read_count: Optional[int] = None
     """Total number of rows read by the query."""
 
+    runnable_tasks: Optional[int] = None
+    """number of remaining tasks to complete, calculated by autoscaler StatementAnalysis.scala
+    deprecated: use remaining_task_count instead"""
+
     spill_to_disk_bytes: Optional[int] = None
     """Size of data temporarily written to disk while executing the query, in bytes."""
 
@@ -6125,6 +5079,11 @@ class QueryMetrics:
     total_time_ms: Optional[int] = None
     """Total execution time of the query from the client’s point of view, in milliseconds."""
 
+    work_to_be_done: Optional[int] = None
+    """remaining work to be done across all stages in the query, calculated by autoscaler
+    StatementAnalysis.scala, in milliseconds deprecated: using
+    projected_remaining_task_total_time_ms instead"""
+
     write_remote_bytes: Optional[int] = None
     """Size pf persistent data written to cloud object storage in your cloud tenant, in bytes."""
 
@@ -6141,6 +5100,8 @@ class QueryMetrics:
             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.projected_remaining_task_total_time_ms is not None:
+            body["projected_remaining_task_total_time_ms"] = self.projected_remaining_task_total_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:
@@ -6159,6 +5120,8 @@ class QueryMetrics:
             body["read_partitions_count"] = self.read_partitions_count
         if self.read_remote_bytes is not None:
             body["read_remote_bytes"] = self.read_remote_bytes
+        if self.remaining_task_count is not None:
+            body["remaining_task_count"] = self.remaining_task_count
         if self.result_fetch_time_ms is not None:
             body["result_fetch_time_ms"] = self.result_fetch_time_ms
         if self.result_from_cache is not None:
@@ -6167,6 +5130,8 @@ class QueryMetrics:
             body["rows_produced_count"] = self.rows_produced_count
         if self.rows_read_count is not None:
             body["rows_read_count"] = self.rows_read_count
+        if self.runnable_tasks is not None:
+            body["runnable_tasks"] = self.runnable_tasks
         if self.spill_to_disk_bytes is not None:
             body["spill_to_disk_bytes"] = self.spill_to_disk_bytes
         if self.task_time_over_time_range:
@@ -6175,6 +5140,8 @@ class QueryMetrics:
             body["task_total_time_ms"] = self.task_total_time_ms
         if self.total_time_ms is not None:
             body["total_time_ms"] = self.total_time_ms
+        if self.work_to_be_done is not None:
+            body["work_to_be_done"] = self.work_to_be_done
         if self.write_remote_bytes is not None:
             body["write_remote_bytes"] = self.write_remote_bytes
         return body
@@ -6192,6 +5159,8 @@ class QueryMetrics:
             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.projected_remaining_task_total_time_ms is not None:
+            body["projected_remaining_task_total_time_ms"] = self.projected_remaining_task_total_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:
@@ -6210,6 +5179,8 @@ class QueryMetrics:
             body["read_partitions_count"] = self.read_partitions_count
         if self.read_remote_bytes is not None:
             body["read_remote_bytes"] = self.read_remote_bytes
+        if self.remaining_task_count is not None:
+            body["remaining_task_count"] = self.remaining_task_count
         if self.result_fetch_time_ms is not None:
             body["result_fetch_time_ms"] = self.result_fetch_time_ms
         if self.result_from_cache is not None:
@@ -6218,6 +5189,8 @@ class QueryMetrics:
             body["rows_produced_count"] = self.rows_produced_count
         if self.rows_read_count is not None:
             body["rows_read_count"] = self.rows_read_count
+        if self.runnable_tasks is not None:
+            body["runnable_tasks"] = self.runnable_tasks
         if self.spill_to_disk_bytes is not None:
             body["spill_to_disk_bytes"] = self.spill_to_disk_bytes
         if self.task_time_over_time_range:
@@ -6226,6 +5199,8 @@ class QueryMetrics:
             body["task_total_time_ms"] = self.task_total_time_ms
         if self.total_time_ms is not None:
             body["total_time_ms"] = self.total_time_ms
+        if self.work_to_be_done is not None:
+            body["work_to_be_done"] = self.work_to_be_done
         if self.write_remote_bytes is not None:
             body["write_remote_bytes"] = self.write_remote_bytes
         return body
@@ -6239,6 +5214,7 @@ class QueryMetrics:
             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),
+            projected_remaining_task_total_time_ms=d.get("projected_remaining_task_total_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),
@@ -6248,14 +5224,17 @@ class QueryMetrics:
             read_files_count=d.get("read_files_count", None),
             read_partitions_count=d.get("read_partitions_count", None),
             read_remote_bytes=d.get("read_remote_bytes", None),
+            remaining_task_count=d.get("remaining_task_count", None),
             result_fetch_time_ms=d.get("result_fetch_time_ms", None),
             result_from_cache=d.get("result_from_cache", None),
             rows_produced_count=d.get("rows_produced_count", None),
             rows_read_count=d.get("rows_read_count", None),
+            runnable_tasks=d.get("runnable_tasks", None),
             spill_to_disk_bytes=d.get("spill_to_disk_bytes", None),
             task_time_over_time_range=_from_dict(d, "task_time_over_time_range", TaskTimeOverRange),
             task_total_time_ms=d.get("task_total_time_ms", None),
             total_time_ms=d.get("total_time_ms", None),
+            work_to_be_done=d.get("work_to_be_done", None),
             write_remote_bytes=d.get("write_remote_bytes", None),
         )
 
@@ -6395,94 +5374,6 @@ class QueryParameter:
         )
 
 
-@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]
-    
-    [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."""
-
-    name: Optional[str] = None
-    """The title of this query that appears in list views, widget headings, and on the query page."""
-
-    options: Optional[Any] = None
-    """Exclusively used for storing a list parameter definitions. A parameter is an object with
-    `title`, `name`, `type`, and `value` properties. The `value` field here is the default value. It
-    can be overridden at runtime."""
-
-    parent: Optional[str] = None
-    """The identifier of the workspace folder containing the object."""
-
-    query: Optional[str] = None
-    """The text of the query to be run."""
-
-    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
-
-    def as_dict(self) -> dict:
-        """Serializes the QueryPostContent into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        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.name is not None:
-            body["name"] = self.name
-        if self.options:
-            body["options"] = self.options
-        if self.parent is not None:
-            body["parent"] = self.parent
-        if self.query is not None:
-            body["query"] = self.query
-        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]
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the QueryPostContent into a shallow dictionary of its immediate attributes."""
-        body = {}
-        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.name is not None:
-            body["name"] = self.name
-        if self.options:
-            body["options"] = self.options
-        if self.parent is not None:
-            body["parent"] = self.parent
-        if self.query is not None:
-            body["query"] = self.query
-        if self.run_as_role is not None:
-            body["run_as_role"] = self.run_as_role
-        if self.tags:
-            body["tags"] = self.tags
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> QueryPostContent:
-        """Deserializes the QueryPostContent from a dictionary."""
-        return cls(
-            data_source_id=d.get("data_source_id", None),
-            description=d.get("description", None),
-            name=d.get("name", None),
-            options=d.get("options", None),
-            parent=d.get("parent", None),
-            query=d.get("query", None),
-            run_as_role=_enum(d, "run_as_role", RunAsRole),
-            tags=d.get("tags", None),
-        )
-
-
 class QueryStatementType(Enum):
 
     ALTER = "ALTER"
@@ -6672,7 +5563,6 @@ class ResultManifest:
     format: Optional[Format] = None
 
     schema: Optional[ResultSchema] = None
-    """The schema is an ordered list of column descriptions."""
 
     total_byte_count: Optional[int] = None
     """The total number of bytes in the result set. This field is not available when using `INLINE`
@@ -6778,8 +5668,6 @@ class RunAsMode(Enum):
 
 
 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)"""
 
     OWNER = "owner"
     VIEWER = "viewer"
@@ -6840,50 +5728,6 @@ class ServiceErrorCode(Enum):
     WORKSPACE_TEMPORARILY_UNAVAILABLE = "WORKSPACE_TEMPORARILY_UNAVAILABLE"
 
 
-@dataclass
-class SetRequest:
-    """Set object ACL"""
-
-    access_control_list: Optional[List[AccessControl]] = None
-
-    object_id: Optional[str] = None
-    """Object ID. The ACL for the object with this UUID is overwritten by this request's POST content."""
-
-    object_type: Optional[ObjectTypePlural] = None
-    """The type of object permission to set."""
-
-    def as_dict(self) -> dict:
-        """Serializes the SetRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = [v.as_dict() for v in self.access_control_list]
-        if self.object_id is not None:
-            body["objectId"] = self.object_id
-        if self.object_type is not None:
-            body["objectType"] = self.object_type.value
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the SetRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = self.access_control_list
-        if self.object_id is not None:
-            body["objectId"] = self.object_id
-        if self.object_type is not None:
-            body["objectType"] = self.object_type
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> SetRequest:
-        """Deserializes the SetRequest from a dictionary."""
-        return cls(
-            access_control_list=_repeated_dict(d, "access_control_list", AccessControl),
-            object_id=d.get("objectId", None),
-            object_type=_enum(d, "objectType", ObjectTypePlural),
-        )
-
-
 @dataclass
 class SetResponse:
     access_control_list: Optional[List[AccessControl]] = None
@@ -6891,134 +5735,38 @@ class SetResponse:
     object_id: Optional[str] = None
     """An object's type and UUID, separated by a forward slash (/) character."""
 
-    object_type: Optional[ObjectType] = None
-    """A singular noun object type."""
-
-    def as_dict(self) -> dict:
-        """Serializes the SetResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = [v.as_dict() for v in self.access_control_list]
-        if self.object_id is not None:
-            body["object_id"] = self.object_id
-        if self.object_type is not None:
-            body["object_type"] = self.object_type.value
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the SetResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = self.access_control_list
-        if self.object_id is not None:
-            body["object_id"] = self.object_id
-        if self.object_type is not None:
-            body["object_type"] = self.object_type
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> SetResponse:
-        """Deserializes the SetResponse from a dictionary."""
-        return cls(
-            access_control_list=_repeated_dict(d, "access_control_list", AccessControl),
-            object_id=d.get("object_id", None),
-            object_type=_enum(d, "object_type", ObjectType),
-        )
-
-
-@dataclass
-class SetWorkspaceWarehouseConfigRequest:
-    channel: Optional[Channel] = None
-    """Optional: Channel selection details"""
-
-    config_param: Optional[RepeatedEndpointConfPairs] = None
-    """Deprecated: Use sql_configuration_parameters"""
-
-    data_access_config: Optional[List[EndpointConfPair]] = None
-    """Spark confs for external hive metastore configuration JSON serialized size must be less than <=
-    512K"""
-
-    enabled_warehouse_types: Optional[List[WarehouseTypePair]] = None
-    """List of Warehouse Types allowed in this workspace (limits allowed value of the type field in
-    CreateWarehouse and EditWarehouse). Note: Some types cannot be disabled, they don't need to be
-    specified in SetWorkspaceWarehouseConfig. Note: Disabling a type may cause existing warehouses
-    to be converted to another type. Used by frontend to save specific type availability in the
-    warehouse create and edit form UI."""
-
-    global_param: Optional[RepeatedEndpointConfPairs] = None
-    """Deprecated: Use sql_configuration_parameters"""
-
-    google_service_account: Optional[str] = None
-    """GCP only: Google Service Account used to pass to cluster to access Google Cloud Storage"""
-
-    instance_profile_arn: Optional[str] = None
-    """AWS Only: Instance profile used to pass IAM role to the cluster"""
-
-    security_policy: Optional[SetWorkspaceWarehouseConfigRequestSecurityPolicy] = None
-    """Security policy for warehouses"""
-
-    sql_configuration_parameters: Optional[RepeatedEndpointConfPairs] = None
-    """SQL configuration parameters"""
-
+    object_type: Optional[ObjectType] = None
+    """A singular noun object type."""
+
     def as_dict(self) -> dict:
-        """Serializes the SetWorkspaceWarehouseConfigRequest into a dictionary suitable for use as a JSON request body."""
+        """Serializes the SetResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.channel:
-            body["channel"] = self.channel.as_dict()
-        if self.config_param:
-            body["config_param"] = self.config_param.as_dict()
-        if self.data_access_config:
-            body["data_access_config"] = [v.as_dict() for v in self.data_access_config]
-        if self.enabled_warehouse_types:
-            body["enabled_warehouse_types"] = [v.as_dict() for v in self.enabled_warehouse_types]
-        if self.global_param:
-            body["global_param"] = self.global_param.as_dict()
-        if self.google_service_account is not None:
-            body["google_service_account"] = self.google_service_account
-        if self.instance_profile_arn is not None:
-            body["instance_profile_arn"] = self.instance_profile_arn
-        if self.security_policy is not None:
-            body["security_policy"] = self.security_policy.value
-        if self.sql_configuration_parameters:
-            body["sql_configuration_parameters"] = self.sql_configuration_parameters.as_dict()
+        if self.access_control_list:
+            body["access_control_list"] = [v.as_dict() for v in self.access_control_list]
+        if self.object_id is not None:
+            body["object_id"] = self.object_id
+        if self.object_type is not None:
+            body["object_type"] = self.object_type.value
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the SetWorkspaceWarehouseConfigRequest into a shallow dictionary of its immediate attributes."""
+        """Serializes the SetResponse into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.channel:
-            body["channel"] = self.channel
-        if self.config_param:
-            body["config_param"] = self.config_param
-        if self.data_access_config:
-            body["data_access_config"] = self.data_access_config
-        if self.enabled_warehouse_types:
-            body["enabled_warehouse_types"] = self.enabled_warehouse_types
-        if self.global_param:
-            body["global_param"] = self.global_param
-        if self.google_service_account is not None:
-            body["google_service_account"] = self.google_service_account
-        if self.instance_profile_arn is not None:
-            body["instance_profile_arn"] = self.instance_profile_arn
-        if self.security_policy is not None:
-            body["security_policy"] = self.security_policy
-        if self.sql_configuration_parameters:
-            body["sql_configuration_parameters"] = self.sql_configuration_parameters
+        if self.access_control_list:
+            body["access_control_list"] = self.access_control_list
+        if self.object_id is not None:
+            body["object_id"] = self.object_id
+        if self.object_type is not None:
+            body["object_type"] = self.object_type
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> SetWorkspaceWarehouseConfigRequest:
-        """Deserializes the SetWorkspaceWarehouseConfigRequest from a dictionary."""
+    def from_dict(cls, d: Dict[str, Any]) -> SetResponse:
+        """Deserializes the SetResponse from a dictionary."""
         return cls(
-            channel=_from_dict(d, "channel", Channel),
-            config_param=_from_dict(d, "config_param", RepeatedEndpointConfPairs),
-            data_access_config=_repeated_dict(d, "data_access_config", EndpointConfPair),
-            enabled_warehouse_types=_repeated_dict(d, "enabled_warehouse_types", WarehouseTypePair),
-            global_param=_from_dict(d, "global_param", RepeatedEndpointConfPairs),
-            google_service_account=d.get("google_service_account", None),
-            instance_profile_arn=d.get("instance_profile_arn", None),
-            security_policy=_enum(d, "security_policy", SetWorkspaceWarehouseConfigRequestSecurityPolicy),
-            sql_configuration_parameters=_from_dict(d, "sql_configuration_parameters", RepeatedEndpointConfPairs),
+            access_control_list=_repeated_dict(d, "access_control_list", AccessControl),
+            object_id=d.get("object_id", None),
+            object_type=_enum(d, "object_type", ObjectType),
         )
 
 
@@ -7132,7 +5880,6 @@ class StatementParameterListItem:
 @dataclass
 class StatementResponse:
     manifest: Optional[ResultManifest] = None
-    """The result manifest provides schema and metadata for the result set."""
 
     result: Optional[ResultData] = None
 
@@ -7141,7 +5888,6 @@ class StatementResponse:
     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."""
@@ -7202,11 +5948,6 @@ class StatementStatus:
     error: Optional[ServiceError] = None
 
     state: Optional[StatementState] = None
-    """Statement execution state: - `PENDING`: waiting for warehouse - `RUNNING`: running -
-    `SUCCEEDED`: execution was successful, result data available for fetch - `FAILED`: execution
-    failed; reason for failure described in accomanying error message - `CANCELED`: user canceled;
-    can come from explicit cancel call, or timeout with `on_wait_timeout=CANCEL` - `CLOSED`:
-    execution successful, and statement closed; result no longer available for fetch"""
 
     def as_dict(self) -> dict:
         """Serializes the StatementStatus into a dictionary suitable for use as a JSON request body."""
@@ -7562,109 +6303,6 @@ class TransferOwnershipObjectId:
         return cls(new_owner=d.get("new_owner", None))
 
 
-@dataclass
-class TransferOwnershipRequest:
-    """Transfer object ownership"""
-
-    new_owner: Optional[str] = None
-    """Email address for the new owner, who must exist in the workspace."""
-
-    object_id: Optional[TransferOwnershipObjectId] = None
-    """The ID of the object on which to change ownership."""
-
-    object_type: Optional[OwnableObjectType] = None
-    """The type of object on which to change ownership."""
-
-    def as_dict(self) -> dict:
-        """Serializes the TransferOwnershipRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.new_owner is not None:
-            body["new_owner"] = self.new_owner
-        if self.object_id:
-            body["objectId"] = self.object_id.as_dict()
-        if self.object_type is not None:
-            body["objectType"] = self.object_type.value
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the TransferOwnershipRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.new_owner is not None:
-            body["new_owner"] = self.new_owner
-        if self.object_id:
-            body["objectId"] = self.object_id
-        if self.object_type is not None:
-            body["objectType"] = self.object_type
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> TransferOwnershipRequest:
-        """Deserializes the TransferOwnershipRequest from a dictionary."""
-        return cls(
-            new_owner=d.get("new_owner", None),
-            object_id=_from_dict(d, "objectId", TransferOwnershipObjectId),
-            object_type=_enum(d, "objectType", OwnableObjectType),
-        )
-
-
-@dataclass
-class UpdateAlertRequest:
-    update_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    alert: Optional[UpdateAlertRequestAlert] = None
-
-    auto_resolve_display_name: Optional[bool] = None
-    """If true, automatically resolve alert display name conflicts. Otherwise, fail the request if the
-    alert's display name conflicts with an existing alert's display name."""
-
-    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.auto_resolve_display_name is not None:
-            body["auto_resolve_display_name"] = self.auto_resolve_display_name
-        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
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateAlertRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.alert:
-            body["alert"] = self.alert
-        if self.auto_resolve_display_name is not None:
-            body["auto_resolve_display_name"] = self.auto_resolve_display_name
-        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),
-            auto_resolve_display_name=d.get("auto_resolve_display_name", None),
-            id=d.get("id", None),
-            update_mask=d.get("update_mask", None),
-        )
-
-
 @dataclass
 class UpdateAlertRequestAlert:
     condition: Optional[AlertCondition] = None
@@ -7754,64 +6392,6 @@ class UpdateAlertRequestAlert:
         )
 
 
-@dataclass
-class UpdateQueryRequest:
-    update_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    auto_resolve_display_name: Optional[bool] = None
-    """If true, automatically resolve alert display name conflicts. Otherwise, fail the request if the
-    alert's display name conflicts with an existing alert's display name."""
-
-    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.auto_resolve_display_name is not None:
-            body["auto_resolve_display_name"] = self.auto_resolve_display_name
-        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
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateQueryRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.auto_resolve_display_name is not None:
-            body["auto_resolve_display_name"] = self.auto_resolve_display_name
-        if self.id is not None:
-            body["id"] = self.id
-        if self.query:
-            body["query"] = self.query
-        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(
-            auto_resolve_display_name=d.get("auto_resolve_display_name", None),
-            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
@@ -7936,55 +6516,6 @@ class UpdateResponse:
         return cls()
 
 
-@dataclass
-class UpdateVisualizationRequest:
-    update_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    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
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateVisualizationRequest into a shallow dictionary of its immediate attributes."""
-        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
-        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
@@ -8165,7 +6696,6 @@ class WarehouseAccessControlRequest:
     """name of the group"""
 
     permission_level: Optional[WarehousePermissionLevel] = None
-    """Permission level"""
 
     service_principal_name: Optional[str] = None
     """application ID of a service principal"""
@@ -8276,7 +6806,6 @@ class WarehousePermission:
     inherited_from_object: Optional[List[str]] = None
 
     permission_level: Optional[WarehousePermissionLevel] = None
-    """Permission level"""
 
     def as_dict(self) -> dict:
         """Serializes the WarehousePermission into a dictionary suitable for use as a JSON request body."""
@@ -8365,7 +6894,6 @@ class WarehousePermissionsDescription:
     description: Optional[str] = None
 
     permission_level: Optional[WarehousePermissionLevel] = None
-    """Permission level"""
 
     def as_dict(self) -> dict:
         """Serializes the WarehousePermissionsDescription into a dictionary suitable for use as a JSON request body."""
@@ -8394,40 +6922,6 @@ class WarehousePermissionsDescription:
         )
 
 
-@dataclass
-class WarehousePermissionsRequest:
-    access_control_list: Optional[List[WarehouseAccessControlRequest]] = None
-
-    warehouse_id: Optional[str] = None
-    """The SQL warehouse for which to get or manage permissions."""
-
-    def as_dict(self) -> dict:
-        """Serializes the WarehousePermissionsRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = [v.as_dict() for v in self.access_control_list]
-        if self.warehouse_id is not None:
-            body["warehouse_id"] = self.warehouse_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the WarehousePermissionsRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = self.access_control_list
-        if self.warehouse_id is not None:
-            body["warehouse_id"] = self.warehouse_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> WarehousePermissionsRequest:
-        """Deserializes the WarehousePermissionsRequest from a dictionary."""
-        return cls(
-            access_control_list=_repeated_dict(d, "access_control_list", WarehouseAccessControlRequest),
-            warehouse_id=d.get("warehouse_id", None),
-        )
-
-
 @dataclass
 class WarehouseTypePair:
     enabled: Optional[bool] = None
@@ -8914,6 +7408,7 @@ class AlertsLegacyAPI:
 
         [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
 
+
         :returns: Iterator over :class:`LegacyAlert`
         """
 
@@ -9090,7 +7585,7 @@ class DashboardWidgetsAPI:
         text: Optional[str] = None,
         visualization_id: Optional[str] = None,
     ) -> Widget:
-        """Add widget to a dashboard
+        """Adds a widget to a dashboard
 
         :param dashboard_id: str
           Dashboard ID returned by :method:dashboards/create.
@@ -9125,7 +7620,7 @@ class DashboardWidgetsAPI:
         return Widget.from_dict(res)
 
     def delete(self, id: str):
-        """Remove widget
+        """Removes a widget from a dashboard
 
         :param id: str
           Widget ID returned by :method:dashboardwidgets/create
@@ -9149,7 +7644,7 @@ class DashboardWidgetsAPI:
         text: Optional[str] = None,
         visualization_id: Optional[str] = None,
     ) -> Widget:
-        """Update existing widget
+        """Updates an existing widget
 
         :param id: str
           Widget ID returned by :method:dashboardwidgets/create
@@ -9196,54 +7691,6 @@ class DashboardsAPI:
     def __init__(self, api_client):
         self._api = api_client
 
-    def create(
-        self,
-        name: str,
-        *,
-        dashboard_filters_enabled: Optional[bool] = None,
-        is_favorite: Optional[bool] = None,
-        parent: Optional[str] = None,
-        run_as_role: Optional[RunAsRole] = None,
-        tags: Optional[List[str]] = None,
-    ) -> Dashboard:
-        """Create a dashboard object.
-
-        :param name: str
-          The title of this dashboard that appears in list views and at the top of the dashboard page.
-        :param dashboard_filters_enabled: bool (optional)
-          Indicates whether the dashboard filters are enabled
-        :param is_favorite: bool (optional)
-          Indicates whether this dashboard object should appear in the current user's favorites list.
-        :param parent: str (optional)
-          The identifier of the workspace folder containing the object.
-        :param run_as_role: :class:`RunAsRole` (optional)
-          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)
-        :param tags: List[str] (optional)
-
-        :returns: :class:`Dashboard`
-        """
-        body = {}
-        if dashboard_filters_enabled is not None:
-            body["dashboard_filters_enabled"] = dashboard_filters_enabled
-        if is_favorite is not None:
-            body["is_favorite"] = is_favorite
-        if name is not None:
-            body["name"] = name
-        if parent is not None:
-            body["parent"] = parent
-        if run_as_role is not None:
-            body["run_as_role"] = run_as_role.value
-        if tags is not None:
-            body["tags"] = [v for v in tags]
-        headers = {
-            "Accept": "application/json",
-            "Content-Type": "application/json",
-        }
-
-        res = self._api.do("POST", "/api/2.0/preview/sql/dashboards", body=body, headers=headers)
-        return Dashboard.from_dict(res)
-
     def delete(self, dashboard_id: str):
         """Moves a dashboard to the trash. Trashed dashboards do not appear in list views or searches, and cannot
         be shared.
@@ -9312,17 +7759,11 @@ class DashboardsAPI:
             "Accept": "application/json",
         }
 
-        # deduplicate items that may have been added during iteration
-        seen = set()
         query["page"] = 1
         while True:
             json = self._api.do("GET", "/api/2.0/preview/sql/dashboards", query=query, headers=headers)
             if "results" in json:
                 for v in json["results"]:
-                    i = v["id"]
-                    if i in seen:
-                        continue
-                    seen.add(i)
                     yield Dashboard.from_dict(v)
             if "results" not in json or not json["results"]:
                 return
@@ -9407,6 +7848,7 @@ class DataSourcesAPI:
 
         [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
 
+
         :returns: Iterator over :class:`DataSource`
         """
 
@@ -9885,17 +8327,11 @@ class QueriesLegacyAPI:
             "Accept": "application/json",
         }
 
-        # deduplicate items that may have been added during iteration
-        seen = set()
         query["page"] = 1
         while True:
             json = self._api.do("GET", "/api/2.0/preview/sql/queries", query=query, headers=headers)
             if "results" in json:
                 for v in json["results"]:
-                    i = v["id"]
-                    if i in seen:
-                        continue
-                    seen.add(i)
                     yield LegacyQuery.from_dict(v)
             if "results" not in json or not json["results"]:
                 return
@@ -10130,7 +8566,7 @@ class QueryVisualizationsLegacyAPI:
         self._api = api_client
 
     def create(
-        self, query_id: str, type: str, options: Any, *, description: Optional[str] = None, name: Optional[str] = None
+        self, options: Any, query_id: str, type: str, *, description: Optional[str] = None, name: Optional[str] = None
     ) -> LegacyVisualization:
         """Creates visualization in the query.
 
@@ -10139,13 +8575,13 @@ class QueryVisualizationsLegacyAPI:
 
         [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
 
+        :param options: Any
+          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_id: str
           The identifier returned by :method:queries/create
         :param type: str
           The type of visualization: chart, table, pivot table, and so on.
-        :param options: Any
-          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 description: str (optional)
           A short description of this visualization. This is not displayed in the UI.
         :param name: str (optional)
@@ -10181,7 +8617,7 @@ class QueryVisualizationsLegacyAPI:
         [Learn more]: https://docs.databricks.com/en/sql/dbsql-api-latest.html
 
         :param id: str
-          Widget ID returned by :method:queryvizualisations/create
+          Widget ID returned by :method:queryvisualizations/create
 
 
         """
@@ -10261,6 +8697,7 @@ class RedashConfigAPI:
     def get_config(self) -> ClientConfig:
         """Read workspace configuration for Redash-v2.
 
+
         :returns: :class:`ClientConfig`
         """
 
@@ -10394,7 +8831,8 @@ class StatementExecutionAPI:
         """Execute a SQL statement
 
         :param statement: str
-          The SQL statement to execute. The statement can optionally be parameterized, see `parameters`.
+          The SQL statement to execute. The statement can optionally be parameterized, see `parameters`. The
+          maximum query text size is 16 MiB.
         :param warehouse_id: str
           Warehouse upon which to execute a statement. See also [What are SQL warehouses?]
 
@@ -10712,15 +9150,12 @@ class WarehousesAPI:
 
           Supported values: - Must be unique within an org. - Must be less than 100 characters.
         :param spot_instance_policy: :class:`SpotInstancePolicy` (optional)
-          Configurations whether the warehouse should use spot instances.
         :param tags: :class:`EndpointTags` (optional)
           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.
         :param warehouse_type: :class:`CreateWarehouseRequestWarehouseType` (optional)
-          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`.
 
         :returns:
           Long-running operation waiter for :class:`GetWarehouseResponse`.
@@ -10881,15 +9316,12 @@ class WarehousesAPI:
 
           Supported values: - Must be unique within an org. - Must be less than 100 characters.
         :param spot_instance_policy: :class:`SpotInstancePolicy` (optional)
-          Configurations whether the warehouse should use spot instances.
         :param tags: :class:`EndpointTags` (optional)
           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.
         :param warehouse_type: :class:`EditWarehouseRequestWarehouseType` (optional)
-          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`.
 
         :returns:
           Long-running operation waiter for :class:`GetWarehouseResponse`.
@@ -11018,6 +9450,7 @@ class WarehousesAPI:
     def get_workspace_warehouse_config(self) -> GetWorkspaceWarehouseConfigResponse:
         """Gets the workspace level configuration that is shared by all SQL warehouses in a workspace.
 
+
         :returns: :class:`GetWorkspaceWarehouseConfigResponse`
         """