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

databricks/sdk/service/compute.py

@@ -19,70 +19,6 @@ _LOG = logging.getLogger("databricks.sdk")
 # all definitions in this file are in alphabetical order
 
 
-@dataclass
-class AddInstanceProfile:
-    instance_profile_arn: str
-    """The AWS ARN of the instance profile to register with Databricks. This field is required."""
-
-    iam_role_arn: Optional[str] = None
-    """The AWS IAM role ARN of the role associated with the instance profile. This field is required if
-    your role name and instance profile name do not match and you want to use the instance profile
-    with [Databricks SQL Serverless].
-    
-    Otherwise, this field is optional.
-    
-    [Databricks SQL Serverless]: https://docs.databricks.com/sql/admin/serverless.html"""
-
-    is_meta_instance_profile: Optional[bool] = None
-    """Boolean flag indicating whether the instance profile should only be used in credential
-    passthrough scenarios. If true, it means the instance profile contains an meta IAM role which
-    could assume a wide range of roles. Therefore it should always be used with authorization. This
-    field is optional, the default value is `false`."""
-
-    skip_validation: Optional[bool] = None
-    """By default, Databricks validates that it has sufficient permissions to launch instances with the
-    instance profile. This validation uses AWS dry-run mode for the RunInstances API. If validation
-    fails with an error message that does not indicate an IAM related permission issue, (e.g.
-    “Your requested instance type is not supported in your requested availability zone”), you
-    can pass this flag to skip the validation and forcibly add the instance profile."""
-
-    def as_dict(self) -> dict:
-        """Serializes the AddInstanceProfile into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.iam_role_arn is not None:
-            body["iam_role_arn"] = self.iam_role_arn
-        if self.instance_profile_arn is not None:
-            body["instance_profile_arn"] = self.instance_profile_arn
-        if self.is_meta_instance_profile is not None:
-            body["is_meta_instance_profile"] = self.is_meta_instance_profile
-        if self.skip_validation is not None:
-            body["skip_validation"] = self.skip_validation
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the AddInstanceProfile into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.iam_role_arn is not None:
-            body["iam_role_arn"] = self.iam_role_arn
-        if self.instance_profile_arn is not None:
-            body["instance_profile_arn"] = self.instance_profile_arn
-        if self.is_meta_instance_profile is not None:
-            body["is_meta_instance_profile"] = self.is_meta_instance_profile
-        if self.skip_validation is not None:
-            body["skip_validation"] = self.skip_validation
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> AddInstanceProfile:
-        """Deserializes the AddInstanceProfile from a dictionary."""
-        return cls(
-            iam_role_arn=d.get("iam_role_arn", None),
-            instance_profile_arn=d.get("instance_profile_arn", None),
-            is_meta_instance_profile=d.get("is_meta_instance_profile", None),
-            skip_validation=d.get("skip_validation", None),
-        )
-
-
 @dataclass
 class AddResponse:
     def as_dict(self) -> dict:
@@ -389,46 +325,6 @@ class AzureAvailability(Enum):
     SPOT_WITH_FALLBACK_AZURE = "SPOT_WITH_FALLBACK_AZURE"
 
 
-@dataclass
-class CancelCommand:
-    cluster_id: Optional[str] = None
-
-    command_id: Optional[str] = None
-
-    context_id: Optional[str] = None
-
-    def as_dict(self) -> dict:
-        """Serializes the CancelCommand into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.cluster_id is not None:
-            body["clusterId"] = self.cluster_id
-        if self.command_id is not None:
-            body["commandId"] = self.command_id
-        if self.context_id is not None:
-            body["contextId"] = self.context_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CancelCommand into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.cluster_id is not None:
-            body["clusterId"] = self.cluster_id
-        if self.command_id is not None:
-            body["commandId"] = self.command_id
-        if self.context_id is not None:
-            body["contextId"] = self.context_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CancelCommand:
-        """Deserializes the CancelCommand from a dictionary."""
-        return cls(
-            cluster_id=d.get("clusterId", None),
-            command_id=d.get("commandId", None),
-            context_id=d.get("contextId", None),
-        )
-
-
 @dataclass
 class CancelResponse:
     def as_dict(self) -> dict:
@@ -447,37 +343,6 @@ class CancelResponse:
         return cls()
 
 
-@dataclass
-class ChangeClusterOwner:
-    cluster_id: str
-
-    owner_username: str
-    """New owner of the cluster_id after this RPC."""
-
-    def as_dict(self) -> dict:
-        """Serializes the ChangeClusterOwner into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        if self.owner_username is not None:
-            body["owner_username"] = self.owner_username
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the ChangeClusterOwner into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        if self.owner_username is not None:
-            body["owner_username"] = self.owner_username
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> ChangeClusterOwner:
-        """Deserializes the ChangeClusterOwner from a dictionary."""
-        return cls(cluster_id=d.get("cluster_id", None), owner_username=d.get("owner_username", None))
-
-
 @dataclass
 class ChangeClusterOwnerResponse:
     def as_dict(self) -> dict:
@@ -1820,40 +1685,6 @@ class ClusterPermissionsDescription:
         )
 
 
-@dataclass
-class ClusterPermissionsRequest:
-    access_control_list: Optional[List[ClusterAccessControlRequest]] = None
-
-    cluster_id: Optional[str] = None
-    """The cluster for which to get or manage permissions."""
-
-    def as_dict(self) -> dict:
-        """Serializes the ClusterPermissionsRequest 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.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the ClusterPermissionsRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = self.access_control_list
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> ClusterPermissionsRequest:
-        """Deserializes the ClusterPermissionsRequest from a dictionary."""
-        return cls(
-            access_control_list=_repeated_dict(d, "access_control_list", ClusterAccessControlRequest),
-            cluster_id=d.get("cluster_id", None),
-        )
-
-
 @dataclass
 class ClusterPolicyAccessControlRequest:
     group_name: Optional[str] = None
@@ -2082,40 +1913,6 @@ class ClusterPolicyPermissionsDescription:
         )
 
 
-@dataclass
-class ClusterPolicyPermissionsRequest:
-    access_control_list: Optional[List[ClusterPolicyAccessControlRequest]] = None
-
-    cluster_policy_id: Optional[str] = None
-    """The cluster policy for which to get or manage permissions."""
-
-    def as_dict(self) -> dict:
-        """Serializes the ClusterPolicyPermissionsRequest 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.cluster_policy_id is not None:
-            body["cluster_policy_id"] = self.cluster_policy_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the ClusterPolicyPermissionsRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = self.access_control_list
-        if self.cluster_policy_id is not None:
-            body["cluster_policy_id"] = self.cluster_policy_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> ClusterPolicyPermissionsRequest:
-        """Deserializes the ClusterPolicyPermissionsRequest from a dictionary."""
-        return cls(
-            access_control_list=_repeated_dict(d, "access_control_list", ClusterPolicyAccessControlRequest),
-            cluster_policy_id=d.get("cluster_policy_id", None),
-        )
-
-
 @dataclass
 class ClusterSettingsChange:
     """Represents a change to the cluster settings required for the cluster to become compliant with
@@ -2561,56 +2358,6 @@ class ClusterSpec:
         )
 
 
-@dataclass
-class Command:
-    cluster_id: Optional[str] = None
-    """Running cluster id"""
-
-    command: Optional[str] = None
-    """Executable code"""
-
-    context_id: Optional[str] = None
-    """Running context id"""
-
-    language: Optional[Language] = None
-
-    def as_dict(self) -> dict:
-        """Serializes the Command into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.cluster_id is not None:
-            body["clusterId"] = self.cluster_id
-        if self.command is not None:
-            body["command"] = self.command
-        if self.context_id is not None:
-            body["contextId"] = self.context_id
-        if self.language is not None:
-            body["language"] = self.language.value
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the Command into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.cluster_id is not None:
-            body["clusterId"] = self.cluster_id
-        if self.command is not None:
-            body["command"] = self.command
-        if self.context_id is not None:
-            body["contextId"] = self.context_id
-        if self.language is not None:
-            body["language"] = self.language
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> Command:
-        """Deserializes the Command from a dictionary."""
-        return cls(
-            cluster_id=d.get("clusterId", None),
-            command=d.get("command", None),
-            context_id=d.get("contextId", None),
-            language=_enum(d, "language", Language),
-        )
-
-
 class CommandStatus(Enum):
 
     CANCELLED = "Cancelled"
@@ -2697,1896 +2444,605 @@ class ContextStatusResponse:
 
 
 @dataclass
-class CreateCluster:
-    spark_version: str
-    """The Spark version of the cluster, e.g. `3.3.x-scala2.11`. A list of available Spark versions can
-    be retrieved by using the :method:clusters/sparkVersions API call."""
+class CreateClusterResponse:
+    cluster_id: Optional[str] = None
 
-    apply_policy_default_values: Optional[bool] = None
-    """When set to true, fixed and default values from the policy will be used for fields that are
-    omitted. When set to false, only fixed values from the policy will be applied."""
+    def as_dict(self) -> dict:
+        """Serializes the CreateClusterResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.cluster_id is not None:
+            body["cluster_id"] = self.cluster_id
+        return body
 
-    autoscale: Optional[AutoScale] = None
-    """Parameters needed in order to automatically scale clusters up and down based on load. Note:
-    autoscaling works best with DB runtime versions 3.0 or later."""
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateClusterResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.cluster_id is not None:
+            body["cluster_id"] = self.cluster_id
+        return body
 
-    autotermination_minutes: Optional[int] = None
-    """Automatically terminates the cluster after it is inactive for this time in minutes. If not set,
-    this cluster will not be automatically terminated. If specified, the threshold must be between
-    10 and 10000 minutes. Users can also set this value to 0 to explicitly disable automatic
-    termination."""
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> CreateClusterResponse:
+        """Deserializes the CreateClusterResponse from a dictionary."""
+        return cls(cluster_id=d.get("cluster_id", None))
 
-    aws_attributes: Optional[AwsAttributes] = None
-    """Attributes related to clusters running on Amazon Web Services. If not specified at cluster
-    creation, a set of default values will be used."""
 
-    azure_attributes: Optional[AzureAttributes] = None
-    """Attributes related to clusters running on Microsoft Azure. If not specified at cluster creation,
-    a set of default values will be used."""
+@dataclass
+class CreateInstancePoolResponse:
+    instance_pool_id: Optional[str] = None
+    """The ID of the created instance pool."""
 
-    clone_from: Optional[CloneCluster] = None
-    """When specified, this clones libraries from a source cluster during the creation of a new
-    cluster."""
+    def as_dict(self) -> dict:
+        """Serializes the CreateInstancePoolResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.instance_pool_id is not None:
+            body["instance_pool_id"] = self.instance_pool_id
+        return body
 
-    cluster_log_conf: Optional[ClusterLogConf] = None
-    """The configuration for delivering spark logs to a long-term storage destination. Three kinds of
-    destinations (DBFS, S3 and Unity Catalog volumes) are supported. Only one destination can be
-    specified for one cluster. If the conf is given, the logs will be delivered to the destination
-    every `5 mins`. The destination of driver logs is `$destination/$clusterId/driver`, while the
-    destination of executor logs is `$destination/$clusterId/executor`."""
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateInstancePoolResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.instance_pool_id is not None:
+            body["instance_pool_id"] = self.instance_pool_id
+        return body
 
-    cluster_name: Optional[str] = None
-    """Cluster name requested by the user. This doesn't have to be unique. If not specified at
-    creation, the cluster name will be an empty string. For job clusters, the cluster name is
-    automatically set based on the job and job run IDs."""
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> CreateInstancePoolResponse:
+        """Deserializes the CreateInstancePoolResponse from a dictionary."""
+        return cls(instance_pool_id=d.get("instance_pool_id", None))
 
-    custom_tags: Optional[Dict[str, str]] = None
-    """Additional tags for cluster resources. Databricks will tag all cluster resources (e.g., AWS
-    instances and EBS volumes) with these tags in addition to `default_tags`. Notes:
-    
-    - Currently, Databricks allows at most 45 custom tags
-    
-    - Clusters can only reuse cloud resources if the resources' tags are a subset of the cluster
-    tags"""
 
-    data_security_mode: Optional[DataSecurityMode] = None
+@dataclass
+class CreatePolicyResponse:
+    policy_id: Optional[str] = None
+    """Canonical unique identifier for the cluster policy."""
 
-    docker_image: Optional[DockerImage] = None
-    """Custom docker image BYOC"""
+    def as_dict(self) -> dict:
+        """Serializes the CreatePolicyResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.policy_id is not None:
+            body["policy_id"] = self.policy_id
+        return body
 
-    driver_instance_pool_id: Optional[str] = None
-    """The optional ID of the instance pool for the driver of the cluster belongs. The pool cluster
-    uses the instance pool with id (instance_pool_id) if the driver pool is not assigned."""
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreatePolicyResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.policy_id is not None:
+            body["policy_id"] = self.policy_id
+        return body
 
-    driver_node_type_id: Optional[str] = None
-    """The node type of the Spark driver. Note that this field is optional; if unset, the driver node
-    type will be set as the same value as `node_type_id` defined above.
-    
-    This field, along with node_type_id, should not be set if virtual_cluster_size is set. If both
-    driver_node_type_id, node_type_id, and virtual_cluster_size are specified, driver_node_type_id
-    and node_type_id take precedence."""
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> CreatePolicyResponse:
+        """Deserializes the CreatePolicyResponse from a dictionary."""
+        return cls(policy_id=d.get("policy_id", None))
 
-    enable_elastic_disk: Optional[bool] = None
-    """Autoscaling Local Storage: when enabled, this cluster will dynamically acquire additional disk
-    space when its Spark workers are running low on disk space. This feature requires specific AWS
-    permissions to function correctly - refer to the User Guide for more details."""
 
-    enable_local_disk_encryption: Optional[bool] = None
-    """Whether to enable LUKS on cluster VMs' local disks"""
+@dataclass
+class CreateResponse:
+    script_id: Optional[str] = None
+    """The global init script ID."""
 
-    gcp_attributes: Optional[GcpAttributes] = None
-    """Attributes related to clusters running on Google Cloud Platform. If not specified at cluster
-    creation, a set of default values will be used."""
+    def as_dict(self) -> dict:
+        """Serializes the CreateResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.script_id is not None:
+            body["script_id"] = self.script_id
+        return body
 
-    init_scripts: Optional[List[InitScriptInfo]] = None
-    """The configuration for storing init scripts. Any number of destinations can be specified. The
-    scripts are executed sequentially in the order provided. If `cluster_log_conf` is specified,
-    init script logs are sent to `<destination>/<cluster-ID>/init_scripts`."""
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.script_id is not None:
+            body["script_id"] = self.script_id
+        return body
 
-    instance_pool_id: Optional[str] = None
-    """The optional ID of the instance pool to which the cluster belongs."""
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> CreateResponse:
+        """Deserializes the CreateResponse from a dictionary."""
+        return cls(script_id=d.get("script_id", None))
 
-    is_single_node: Optional[bool] = None
-    """This field can only be used when `kind = CLASSIC_PREVIEW`.
-    
-    When set to true, Databricks will automatically set single node related `custom_tags`,
-    `spark_conf`, and `num_workers`"""
 
-    kind: Optional[Kind] = None
+@dataclass
+class Created:
+    id: Optional[str] = None
 
-    node_type_id: Optional[str] = None
-    """This field encodes, through a single value, the resources available to each of the Spark nodes
-    in this cluster. For example, the Spark nodes can be provisioned and optimized for memory or
-    compute intensive workloads. A list of available node types can be retrieved by using the
-    :method:clusters/listNodeTypes API call."""
+    def as_dict(self) -> dict:
+        """Serializes the Created into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.id is not None:
+            body["id"] = self.id
+        return body
 
-    num_workers: Optional[int] = None
-    """Number of worker nodes that this cluster should have. A cluster has one Spark Driver and
-    `num_workers` Executors for a total of `num_workers` + 1 Spark nodes.
-    
-    Note: When reading the properties of a cluster, this field reflects the desired number of
-    workers rather than the actual current number of workers. For instance, if a cluster is resized
-    from 5 to 10 workers, this field will immediately be updated to reflect the target size of 10
-    workers, whereas the workers listed in `spark_info` will gradually increase from 5 to 10 as the
-    new nodes are provisioned."""
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Created into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.id is not None:
+            body["id"] = self.id
+        return body
 
-    policy_id: Optional[str] = None
-    """The ID of the cluster policy used to create the cluster if applicable."""
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> Created:
+        """Deserializes the Created from a dictionary."""
+        return cls(id=d.get("id", None))
 
-    remote_disk_throughput: Optional[int] = None
-    """If set, what the configurable throughput (in Mb/s) for the remote disk is. Currently only
-    supported for GCP HYPERDISK_BALANCED disks."""
 
-    runtime_engine: Optional[RuntimeEngine] = None
-    """Determines the cluster's runtime engine, either standard or Photon.
-    
-    This field is not compatible with legacy `spark_version` values that contain `-photon-`. Remove
-    `-photon-` from the `spark_version` and set `runtime_engine` to `PHOTON`.
-    
-    If left unspecified, the runtime engine defaults to standard unless the spark_version contains
-    -photon-, in which case Photon will be used."""
+@dataclass
+class CustomPolicyTag:
+    key: str
+    """The key of the tag. - Must be unique among all custom tags of the same policy - Cannot be
+    “budget-policy-name”, “budget-policy-id” or "budget-policy-resolution-result" - these
+    tags are preserved."""
 
-    single_user_name: Optional[str] = None
-    """Single user name if data_security_mode is `SINGLE_USER`"""
+    value: Optional[str] = None
+    """The value of the tag."""
 
-    spark_conf: Optional[Dict[str, str]] = None
-    """An object containing a set of optional, user-specified Spark configuration key-value pairs.
-    Users can also pass in a string of extra JVM options to the driver and the executors via
-    `spark.driver.extraJavaOptions` and `spark.executor.extraJavaOptions` respectively."""
+    def as_dict(self) -> dict:
+        """Serializes the CustomPolicyTag into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.key is not None:
+            body["key"] = self.key
+        if self.value is not None:
+            body["value"] = self.value
+        return body
 
-    spark_env_vars: Optional[Dict[str, str]] = None
-    """An object containing a set of optional, user-specified environment variable key-value pairs.
-    Please note that key-value pair of the form (X,Y) will be exported as is (i.e., `export X='Y'`)
-    while launching the driver and workers.
-    
-    In order to specify an additional set of `SPARK_DAEMON_JAVA_OPTS`, we recommend appending them
-    to `$SPARK_DAEMON_JAVA_OPTS` as shown in the example below. This ensures that all default
-    databricks managed environmental variables are included as well.
-    
-    Example Spark environment variables: `{"SPARK_WORKER_MEMORY": "28000m", "SPARK_LOCAL_DIRS":
-    "/local_disk0"}` or `{"SPARK_DAEMON_JAVA_OPTS": "$SPARK_DAEMON_JAVA_OPTS
-    -Dspark.shuffle.service.enabled=true"}`"""
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CustomPolicyTag into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.key is not None:
+            body["key"] = self.key
+        if self.value is not None:
+            body["value"] = self.value
+        return body
 
-    ssh_public_keys: Optional[List[str]] = None
-    """SSH public key contents that will be added to each Spark node in this cluster. The corresponding
-    private keys can be used to login with the user name `ubuntu` on port `2200`. Up to 10 keys can
-    be specified."""
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> CustomPolicyTag:
+        """Deserializes the CustomPolicyTag from a dictionary."""
+        return cls(key=d.get("key", None), value=d.get("value", None))
 
-    total_initial_remote_disk_size: Optional[int] = None
-    """If set, what the total initial volume size (in GB) of the remote disks should be. Currently only
-    supported for GCP HYPERDISK_BALANCED disks."""
 
-    use_ml_runtime: Optional[bool] = None
-    """This field can only be used when `kind = CLASSIC_PREVIEW`.
-    
-    `effective_spark_version` is determined by `spark_version` (DBR release), this field
-    `use_ml_runtime`, and whether `node_type_id` is gpu node or not."""
+@dataclass
+class DataPlaneEventDetails:
+    event_type: Optional[DataPlaneEventDetailsEventType] = None
 
-    workload_type: Optional[WorkloadType] = None
+    executor_failures: Optional[int] = None
+
+    host_id: Optional[str] = None
+
+    timestamp: Optional[int] = None
 
     def as_dict(self) -> dict:
-        """Serializes the CreateCluster into a dictionary suitable for use as a JSON request body."""
+        """Serializes the DataPlaneEventDetails into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.apply_policy_default_values is not None:
-            body["apply_policy_default_values"] = self.apply_policy_default_values
-        if self.autoscale:
-            body["autoscale"] = self.autoscale.as_dict()
-        if self.autotermination_minutes is not None:
-            body["autotermination_minutes"] = self.autotermination_minutes
-        if self.aws_attributes:
-            body["aws_attributes"] = self.aws_attributes.as_dict()
-        if self.azure_attributes:
-            body["azure_attributes"] = self.azure_attributes.as_dict()
-        if self.clone_from:
-            body["clone_from"] = self.clone_from.as_dict()
-        if self.cluster_log_conf:
-            body["cluster_log_conf"] = self.cluster_log_conf.as_dict()
-        if self.cluster_name is not None:
-            body["cluster_name"] = self.cluster_name
-        if self.custom_tags:
-            body["custom_tags"] = self.custom_tags
-        if self.data_security_mode is not None:
-            body["data_security_mode"] = self.data_security_mode.value
-        if self.docker_image:
-            body["docker_image"] = self.docker_image.as_dict()
-        if self.driver_instance_pool_id is not None:
-            body["driver_instance_pool_id"] = self.driver_instance_pool_id
-        if self.driver_node_type_id is not None:
-            body["driver_node_type_id"] = self.driver_node_type_id
-        if self.enable_elastic_disk is not None:
-            body["enable_elastic_disk"] = self.enable_elastic_disk
-        if self.enable_local_disk_encryption is not None:
-            body["enable_local_disk_encryption"] = self.enable_local_disk_encryption
-        if self.gcp_attributes:
-            body["gcp_attributes"] = self.gcp_attributes.as_dict()
-        if self.init_scripts:
-            body["init_scripts"] = [v.as_dict() for v in self.init_scripts]
-        if self.instance_pool_id is not None:
-            body["instance_pool_id"] = self.instance_pool_id
-        if self.is_single_node is not None:
-            body["is_single_node"] = self.is_single_node
-        if self.kind is not None:
-            body["kind"] = self.kind.value
-        if self.node_type_id is not None:
-            body["node_type_id"] = self.node_type_id
-        if self.num_workers is not None:
-            body["num_workers"] = self.num_workers
-        if self.policy_id is not None:
-            body["policy_id"] = self.policy_id
-        if self.remote_disk_throughput is not None:
-            body["remote_disk_throughput"] = self.remote_disk_throughput
-        if self.runtime_engine is not None:
-            body["runtime_engine"] = self.runtime_engine.value
-        if self.single_user_name is not None:
-            body["single_user_name"] = self.single_user_name
-        if self.spark_conf:
-            body["spark_conf"] = self.spark_conf
-        if self.spark_env_vars:
-            body["spark_env_vars"] = self.spark_env_vars
-        if self.spark_version is not None:
-            body["spark_version"] = self.spark_version
-        if self.ssh_public_keys:
-            body["ssh_public_keys"] = [v for v in self.ssh_public_keys]
-        if self.total_initial_remote_disk_size is not None:
-            body["total_initial_remote_disk_size"] = self.total_initial_remote_disk_size
-        if self.use_ml_runtime is not None:
-            body["use_ml_runtime"] = self.use_ml_runtime
-        if self.workload_type:
-            body["workload_type"] = self.workload_type.as_dict()
+        if self.event_type is not None:
+            body["event_type"] = self.event_type.value
+        if self.executor_failures is not None:
+            body["executor_failures"] = self.executor_failures
+        if self.host_id is not None:
+            body["host_id"] = self.host_id
+        if self.timestamp is not None:
+            body["timestamp"] = self.timestamp
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the CreateCluster into a shallow dictionary of its immediate attributes."""
+        """Serializes the DataPlaneEventDetails into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.apply_policy_default_values is not None:
-            body["apply_policy_default_values"] = self.apply_policy_default_values
-        if self.autoscale:
-            body["autoscale"] = self.autoscale
-        if self.autotermination_minutes is not None:
-            body["autotermination_minutes"] = self.autotermination_minutes
-        if self.aws_attributes:
-            body["aws_attributes"] = self.aws_attributes
-        if self.azure_attributes:
-            body["azure_attributes"] = self.azure_attributes
-        if self.clone_from:
-            body["clone_from"] = self.clone_from
-        if self.cluster_log_conf:
-            body["cluster_log_conf"] = self.cluster_log_conf
-        if self.cluster_name is not None:
-            body["cluster_name"] = self.cluster_name
-        if self.custom_tags:
-            body["custom_tags"] = self.custom_tags
-        if self.data_security_mode is not None:
-            body["data_security_mode"] = self.data_security_mode
-        if self.docker_image:
-            body["docker_image"] = self.docker_image
-        if self.driver_instance_pool_id is not None:
-            body["driver_instance_pool_id"] = self.driver_instance_pool_id
-        if self.driver_node_type_id is not None:
-            body["driver_node_type_id"] = self.driver_node_type_id
-        if self.enable_elastic_disk is not None:
-            body["enable_elastic_disk"] = self.enable_elastic_disk
-        if self.enable_local_disk_encryption is not None:
-            body["enable_local_disk_encryption"] = self.enable_local_disk_encryption
-        if self.gcp_attributes:
-            body["gcp_attributes"] = self.gcp_attributes
-        if self.init_scripts:
-            body["init_scripts"] = self.init_scripts
-        if self.instance_pool_id is not None:
-            body["instance_pool_id"] = self.instance_pool_id
-        if self.is_single_node is not None:
-            body["is_single_node"] = self.is_single_node
-        if self.kind is not None:
-            body["kind"] = self.kind
-        if self.node_type_id is not None:
-            body["node_type_id"] = self.node_type_id
-        if self.num_workers is not None:
-            body["num_workers"] = self.num_workers
-        if self.policy_id is not None:
-            body["policy_id"] = self.policy_id
-        if self.remote_disk_throughput is not None:
-            body["remote_disk_throughput"] = self.remote_disk_throughput
-        if self.runtime_engine is not None:
-            body["runtime_engine"] = self.runtime_engine
-        if self.single_user_name is not None:
-            body["single_user_name"] = self.single_user_name
-        if self.spark_conf:
-            body["spark_conf"] = self.spark_conf
-        if self.spark_env_vars:
-            body["spark_env_vars"] = self.spark_env_vars
-        if self.spark_version is not None:
-            body["spark_version"] = self.spark_version
-        if self.ssh_public_keys:
-            body["ssh_public_keys"] = self.ssh_public_keys
-        if self.total_initial_remote_disk_size is not None:
-            body["total_initial_remote_disk_size"] = self.total_initial_remote_disk_size
-        if self.use_ml_runtime is not None:
-            body["use_ml_runtime"] = self.use_ml_runtime
-        if self.workload_type:
-            body["workload_type"] = self.workload_type
+        if self.event_type is not None:
+            body["event_type"] = self.event_type
+        if self.executor_failures is not None:
+            body["executor_failures"] = self.executor_failures
+        if self.host_id is not None:
+            body["host_id"] = self.host_id
+        if self.timestamp is not None:
+            body["timestamp"] = self.timestamp
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateCluster:
-        """Deserializes the CreateCluster from a dictionary."""
+    def from_dict(cls, d: Dict[str, Any]) -> DataPlaneEventDetails:
+        """Deserializes the DataPlaneEventDetails from a dictionary."""
         return cls(
-            apply_policy_default_values=d.get("apply_policy_default_values", None),
-            autoscale=_from_dict(d, "autoscale", AutoScale),
-            autotermination_minutes=d.get("autotermination_minutes", None),
-            aws_attributes=_from_dict(d, "aws_attributes", AwsAttributes),
-            azure_attributes=_from_dict(d, "azure_attributes", AzureAttributes),
-            clone_from=_from_dict(d, "clone_from", CloneCluster),
-            cluster_log_conf=_from_dict(d, "cluster_log_conf", ClusterLogConf),
-            cluster_name=d.get("cluster_name", None),
-            custom_tags=d.get("custom_tags", None),
-            data_security_mode=_enum(d, "data_security_mode", DataSecurityMode),
-            docker_image=_from_dict(d, "docker_image", DockerImage),
-            driver_instance_pool_id=d.get("driver_instance_pool_id", None),
-            driver_node_type_id=d.get("driver_node_type_id", None),
-            enable_elastic_disk=d.get("enable_elastic_disk", None),
-            enable_local_disk_encryption=d.get("enable_local_disk_encryption", None),
-            gcp_attributes=_from_dict(d, "gcp_attributes", GcpAttributes),
-            init_scripts=_repeated_dict(d, "init_scripts", InitScriptInfo),
-            instance_pool_id=d.get("instance_pool_id", None),
-            is_single_node=d.get("is_single_node", None),
-            kind=_enum(d, "kind", Kind),
-            node_type_id=d.get("node_type_id", None),
-            num_workers=d.get("num_workers", None),
-            policy_id=d.get("policy_id", None),
-            remote_disk_throughput=d.get("remote_disk_throughput", None),
-            runtime_engine=_enum(d, "runtime_engine", RuntimeEngine),
-            single_user_name=d.get("single_user_name", None),
-            spark_conf=d.get("spark_conf", None),
-            spark_env_vars=d.get("spark_env_vars", None),
-            spark_version=d.get("spark_version", None),
-            ssh_public_keys=d.get("ssh_public_keys", None),
-            total_initial_remote_disk_size=d.get("total_initial_remote_disk_size", None),
-            use_ml_runtime=d.get("use_ml_runtime", None),
-            workload_type=_from_dict(d, "workload_type", WorkloadType),
+            event_type=_enum(d, "event_type", DataPlaneEventDetailsEventType),
+            executor_failures=d.get("executor_failures", None),
+            host_id=d.get("host_id", None),
+            timestamp=d.get("timestamp", None),
         )
 
 
+class DataPlaneEventDetailsEventType(Enum):
+
+    NODE_BLACKLISTED = "NODE_BLACKLISTED"
+    NODE_EXCLUDED_DECOMMISSIONED = "NODE_EXCLUDED_DECOMMISSIONED"
+
+
+class DataSecurityMode(Enum):
+    """Data security mode decides what data governance model to use when accessing data from a cluster.
+
+    The following modes can only be used when `kind = CLASSIC_PREVIEW`. * `DATA_SECURITY_MODE_AUTO`:
+    Databricks will choose the most appropriate access mode depending on your compute configuration.
+    * `DATA_SECURITY_MODE_STANDARD`: Alias for `USER_ISOLATION`. * `DATA_SECURITY_MODE_DEDICATED`:
+    Alias for `SINGLE_USER`.
+
+    The following modes can be used regardless of `kind`. * `NONE`: No security isolation for
+    multiple users sharing the cluster. Data governance features are not available in this mode. *
+    `SINGLE_USER`: A secure cluster that can only be exclusively used by a single user specified in
+    `single_user_name`. Most programming languages, cluster features and data governance features
+    are available in this mode. * `USER_ISOLATION`: A secure cluster that can be shared by multiple
+    users. Cluster users are fully isolated so that they cannot see each other's data and
+    credentials. Most data governance features are supported in this mode. But programming languages
+    and cluster features might be limited.
+
+    The following modes are deprecated starting with Databricks Runtime 15.0 and will be removed for
+    future Databricks Runtime versions:
+
+    * `LEGACY_TABLE_ACL`: This mode is for users migrating from legacy Table ACL clusters. *
+    `LEGACY_PASSTHROUGH`: This mode is for users migrating from legacy Passthrough on high
+    concurrency clusters. * `LEGACY_SINGLE_USER`: This mode is for users migrating from legacy
+    Passthrough on standard clusters. * `LEGACY_SINGLE_USER_STANDARD`: This mode provides a way that
+    doesn’t have UC nor passthrough enabled."""
+
+    DATA_SECURITY_MODE_AUTO = "DATA_SECURITY_MODE_AUTO"
+    DATA_SECURITY_MODE_DEDICATED = "DATA_SECURITY_MODE_DEDICATED"
+    DATA_SECURITY_MODE_STANDARD = "DATA_SECURITY_MODE_STANDARD"
+    LEGACY_PASSTHROUGH = "LEGACY_PASSTHROUGH"
+    LEGACY_SINGLE_USER = "LEGACY_SINGLE_USER"
+    LEGACY_SINGLE_USER_STANDARD = "LEGACY_SINGLE_USER_STANDARD"
+    LEGACY_TABLE_ACL = "LEGACY_TABLE_ACL"
+    NONE = "NONE"
+    SINGLE_USER = "SINGLE_USER"
+    USER_ISOLATION = "USER_ISOLATION"
+
+
 @dataclass
-class CreateClusterResponse:
-    cluster_id: Optional[str] = None
+class DbfsStorageInfo:
+    """A storage location in DBFS"""
+
+    destination: str
+    """dbfs destination, e.g. `dbfs:/my/path`"""
 
     def as_dict(self) -> dict:
-        """Serializes the CreateClusterResponse into a dictionary suitable for use as a JSON request body."""
+        """Serializes the DbfsStorageInfo into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
+        if self.destination is not None:
+            body["destination"] = self.destination
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the CreateClusterResponse into a shallow dictionary of its immediate attributes."""
+        """Serializes the DbfsStorageInfo into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
+        if self.destination is not None:
+            body["destination"] = self.destination
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateClusterResponse:
-        """Deserializes the CreateClusterResponse from a dictionary."""
-        return cls(cluster_id=d.get("cluster_id", None))
+    def from_dict(cls, d: Dict[str, Any]) -> DbfsStorageInfo:
+        """Deserializes the DbfsStorageInfo from a dictionary."""
+        return cls(destination=d.get("destination", None))
 
 
 @dataclass
-class CreateContext:
-    cluster_id: Optional[str] = None
-    """Running cluster id"""
-
-    language: Optional[Language] = None
-
+class DeleteClusterResponse:
     def as_dict(self) -> dict:
-        """Serializes the CreateContext into a dictionary suitable for use as a JSON request body."""
+        """Serializes the DeleteClusterResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.cluster_id is not None:
-            body["clusterId"] = self.cluster_id
-        if self.language is not None:
-            body["language"] = self.language.value
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the CreateContext into a shallow dictionary of its immediate attributes."""
+        """Serializes the DeleteClusterResponse into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.cluster_id is not None:
-            body["clusterId"] = self.cluster_id
-        if self.language is not None:
-            body["language"] = self.language
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateContext:
-        """Deserializes the CreateContext from a dictionary."""
-        return cls(cluster_id=d.get("clusterId", None), language=_enum(d, "language", Language))
+    def from_dict(cls, d: Dict[str, Any]) -> DeleteClusterResponse:
+        """Deserializes the DeleteClusterResponse from a dictionary."""
+        return cls()
 
 
 @dataclass
-class CreateInstancePool:
-    instance_pool_name: str
-    """Pool name requested by the user. Pool name must be unique. Length must be between 1 and 100
-    characters."""
+class DeleteInstancePoolResponse:
+    def as_dict(self) -> dict:
+        """Serializes the DeleteInstancePoolResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        return body
 
-    node_type_id: str
-    """This field encodes, through a single value, the resources available to each of the Spark nodes
-    in this cluster. For example, the Spark nodes can be provisioned and optimized for memory or
-    compute intensive workloads. A list of available node types can be retrieved by using the
-    :method:clusters/listNodeTypes API call."""
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeleteInstancePoolResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
 
-    aws_attributes: Optional[InstancePoolAwsAttributes] = None
-    """Attributes related to instance pools running on Amazon Web Services. If not specified at pool
-    creation, a set of default values will be used."""
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> DeleteInstancePoolResponse:
+        """Deserializes the DeleteInstancePoolResponse from a dictionary."""
+        return cls()
 
-    azure_attributes: Optional[InstancePoolAzureAttributes] = None
-    """Attributes related to instance pools running on Azure. If not specified at pool creation, a set
-    of default values will be used."""
 
-    custom_tags: Optional[Dict[str, str]] = None
-    """Additional tags for pool resources. Databricks will tag all pool resources (e.g., AWS instances
-    and EBS volumes) with these tags in addition to `default_tags`. Notes:
-    
-    - Currently, Databricks allows at most 45 custom tags"""
+@dataclass
+class DeletePolicyResponse:
+    def as_dict(self) -> dict:
+        """Serializes the DeletePolicyResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        return body
 
-    disk_spec: Optional[DiskSpec] = None
-    """Defines the specification of the disks that will be attached to all spark containers."""
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeletePolicyResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
 
-    enable_elastic_disk: Optional[bool] = None
-    """Autoscaling Local Storage: when enabled, this instances in this pool will dynamically acquire
-    additional disk space when its Spark workers are running low on disk space. In AWS, this feature
-    requires specific AWS permissions to function correctly - refer to the User Guide for more
-    details."""
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> DeletePolicyResponse:
+        """Deserializes the DeletePolicyResponse from a dictionary."""
+        return cls()
 
-    gcp_attributes: Optional[InstancePoolGcpAttributes] = None
-    """Attributes related to instance pools running on Google Cloud Platform. If not specified at pool
-    creation, a set of default values will be used."""
 
-    idle_instance_autotermination_minutes: Optional[int] = None
-    """Automatically terminates the extra instances in the pool cache after they are inactive for this
-    time in minutes if min_idle_instances requirement is already met. If not set, the extra pool
-    instances will be automatically terminated after a default timeout. If specified, the threshold
-    must be between 0 and 10000 minutes. Users can also set this value to 0 to instantly remove idle
-    instances from the cache if min cache size could still hold."""
+@dataclass
+class DeleteResponse:
+    def as_dict(self) -> dict:
+        """Serializes the DeleteResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        return body
 
-    max_capacity: Optional[int] = None
-    """Maximum number of outstanding instances to keep in the pool, including both instances used by
-    clusters and idle instances. Clusters that require further instance provisioning will fail
-    during upsize requests."""
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeleteResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
 
-    min_idle_instances: Optional[int] = None
-    """Minimum number of idle instances to keep in the instance pool"""
-
-    preloaded_docker_images: Optional[List[DockerImage]] = None
-    """Custom Docker Image BYOC"""
-
-    preloaded_spark_versions: Optional[List[str]] = None
-    """A list containing at most one preloaded Spark image version for the pool. Pool-backed clusters
-    started with the preloaded Spark version will start faster. A list of available Spark versions
-    can be retrieved by using the :method:clusters/sparkVersions API call."""
-
-    remote_disk_throughput: Optional[int] = None
-    """If set, what the configurable throughput (in Mb/s) for the remote disk is. Currently only
-    supported for GCP HYPERDISK_BALANCED types."""
-
-    total_initial_remote_disk_size: Optional[int] = None
-    """If set, what the total initial volume size (in GB) of the remote disks should be. Currently only
-    supported for GCP HYPERDISK_BALANCED types."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateInstancePool into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.aws_attributes:
-            body["aws_attributes"] = self.aws_attributes.as_dict()
-        if self.azure_attributes:
-            body["azure_attributes"] = self.azure_attributes.as_dict()
-        if self.custom_tags:
-            body["custom_tags"] = self.custom_tags
-        if self.disk_spec:
-            body["disk_spec"] = self.disk_spec.as_dict()
-        if self.enable_elastic_disk is not None:
-            body["enable_elastic_disk"] = self.enable_elastic_disk
-        if self.gcp_attributes:
-            body["gcp_attributes"] = self.gcp_attributes.as_dict()
-        if self.idle_instance_autotermination_minutes is not None:
-            body["idle_instance_autotermination_minutes"] = self.idle_instance_autotermination_minutes
-        if self.instance_pool_name is not None:
-            body["instance_pool_name"] = self.instance_pool_name
-        if self.max_capacity is not None:
-            body["max_capacity"] = self.max_capacity
-        if self.min_idle_instances is not None:
-            body["min_idle_instances"] = self.min_idle_instances
-        if self.node_type_id is not None:
-            body["node_type_id"] = self.node_type_id
-        if self.preloaded_docker_images:
-            body["preloaded_docker_images"] = [v.as_dict() for v in self.preloaded_docker_images]
-        if self.preloaded_spark_versions:
-            body["preloaded_spark_versions"] = [v for v in self.preloaded_spark_versions]
-        if self.remote_disk_throughput is not None:
-            body["remote_disk_throughput"] = self.remote_disk_throughput
-        if self.total_initial_remote_disk_size is not None:
-            body["total_initial_remote_disk_size"] = self.total_initial_remote_disk_size
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateInstancePool into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.aws_attributes:
-            body["aws_attributes"] = self.aws_attributes
-        if self.azure_attributes:
-            body["azure_attributes"] = self.azure_attributes
-        if self.custom_tags:
-            body["custom_tags"] = self.custom_tags
-        if self.disk_spec:
-            body["disk_spec"] = self.disk_spec
-        if self.enable_elastic_disk is not None:
-            body["enable_elastic_disk"] = self.enable_elastic_disk
-        if self.gcp_attributes:
-            body["gcp_attributes"] = self.gcp_attributes
-        if self.idle_instance_autotermination_minutes is not None:
-            body["idle_instance_autotermination_minutes"] = self.idle_instance_autotermination_minutes
-        if self.instance_pool_name is not None:
-            body["instance_pool_name"] = self.instance_pool_name
-        if self.max_capacity is not None:
-            body["max_capacity"] = self.max_capacity
-        if self.min_idle_instances is not None:
-            body["min_idle_instances"] = self.min_idle_instances
-        if self.node_type_id is not None:
-            body["node_type_id"] = self.node_type_id
-        if self.preloaded_docker_images:
-            body["preloaded_docker_images"] = self.preloaded_docker_images
-        if self.preloaded_spark_versions:
-            body["preloaded_spark_versions"] = self.preloaded_spark_versions
-        if self.remote_disk_throughput is not None:
-            body["remote_disk_throughput"] = self.remote_disk_throughput
-        if self.total_initial_remote_disk_size is not None:
-            body["total_initial_remote_disk_size"] = self.total_initial_remote_disk_size
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateInstancePool:
-        """Deserializes the CreateInstancePool from a dictionary."""
-        return cls(
-            aws_attributes=_from_dict(d, "aws_attributes", InstancePoolAwsAttributes),
-            azure_attributes=_from_dict(d, "azure_attributes", InstancePoolAzureAttributes),
-            custom_tags=d.get("custom_tags", None),
-            disk_spec=_from_dict(d, "disk_spec", DiskSpec),
-            enable_elastic_disk=d.get("enable_elastic_disk", None),
-            gcp_attributes=_from_dict(d, "gcp_attributes", InstancePoolGcpAttributes),
-            idle_instance_autotermination_minutes=d.get("idle_instance_autotermination_minutes", None),
-            instance_pool_name=d.get("instance_pool_name", None),
-            max_capacity=d.get("max_capacity", None),
-            min_idle_instances=d.get("min_idle_instances", None),
-            node_type_id=d.get("node_type_id", None),
-            preloaded_docker_images=_repeated_dict(d, "preloaded_docker_images", DockerImage),
-            preloaded_spark_versions=d.get("preloaded_spark_versions", None),
-            remote_disk_throughput=d.get("remote_disk_throughput", None),
-            total_initial_remote_disk_size=d.get("total_initial_remote_disk_size", None),
-        )
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> DeleteResponse:
+        """Deserializes the DeleteResponse from a dictionary."""
+        return cls()
 
 
 @dataclass
-class CreateInstancePoolResponse:
-    instance_pool_id: Optional[str] = None
-    """The ID of the created instance pool."""
-
+class DestroyResponse:
     def as_dict(self) -> dict:
-        """Serializes the CreateInstancePoolResponse into a dictionary suitable for use as a JSON request body."""
+        """Serializes the DestroyResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.instance_pool_id is not None:
-            body["instance_pool_id"] = self.instance_pool_id
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the CreateInstancePoolResponse into a shallow dictionary of its immediate attributes."""
+        """Serializes the DestroyResponse into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.instance_pool_id is not None:
-            body["instance_pool_id"] = self.instance_pool_id
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateInstancePoolResponse:
-        """Deserializes the CreateInstancePoolResponse from a dictionary."""
-        return cls(instance_pool_id=d.get("instance_pool_id", None))
+    def from_dict(cls, d: Dict[str, Any]) -> DestroyResponse:
+        """Deserializes the DestroyResponse from a dictionary."""
+        return cls()
 
 
 @dataclass
-class CreatePolicy:
-    definition: Optional[str] = None
-    """Policy definition document expressed in [Databricks Cluster Policy Definition Language].
-    
-    [Databricks Cluster Policy Definition Language]: https://docs.databricks.com/administration-guide/clusters/policy-definition.html"""
-
-    description: Optional[str] = None
-    """Additional human-readable description of the cluster policy."""
-
-    libraries: Optional[List[Library]] = None
-    """A list of libraries to be installed on the next cluster restart that uses this policy. The
-    maximum number of libraries is 500."""
-
-    max_clusters_per_user: Optional[int] = None
-    """Max number of clusters per user that can be active using this policy. If not present, there is
-    no max limit."""
-
-    name: Optional[str] = None
-    """Cluster Policy name requested by the user. This has to be unique. Length must be between 1 and
-    100 characters."""
+class DiskSpec:
+    """Describes the disks that are launched for each instance in the spark cluster. For example, if
+    the cluster has 3 instances, each instance is configured to launch 2 disks, 100 GiB each, then
+    Databricks will launch a total of 6 disks, 100 GiB each, for this cluster."""
 
-    policy_family_definition_overrides: Optional[str] = None
-    """Policy definition JSON document expressed in [Databricks Policy Definition Language]. The JSON
-    document must be passed as a string and cannot be embedded in the requests.
+    disk_count: Optional[int] = None
+    """The number of disks launched for each instance: - This feature is only enabled for supported
+    node types. - Users can choose up to the limit of the disks supported by the node type. - For
+    node types with no OS disk, at least one disk must be specified; otherwise, cluster creation
+    will fail.
     
-    You can use this to customize the policy definition inherited from the policy family. Policy
-    rules specified here are merged into the inherited policy definition.
+    If disks are attached, Databricks will configure Spark to use only the disks for scratch
+    storage, because heterogenously sized scratch devices can lead to inefficient disk utilization.
+    If no disks are attached, Databricks will configure Spark to use instance store disks.
     
-    [Databricks Policy Definition Language]: https://docs.databricks.com/administration-guide/clusters/policy-definition.html"""
-
-    policy_family_id: Optional[str] = None
-    """ID of the policy family. The cluster policy's policy definition inherits the policy family's
-    policy definition.
+    Note: If disks are specified, then the Spark configuration `spark.local.dir` will be overridden.
     
-    Cannot be used with `definition`. Use `policy_family_definition_overrides` instead to customize
-    the policy definition."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreatePolicy into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.definition is not None:
-            body["definition"] = self.definition
-        if self.description is not None:
-            body["description"] = self.description
-        if self.libraries:
-            body["libraries"] = [v.as_dict() for v in self.libraries]
-        if self.max_clusters_per_user is not None:
-            body["max_clusters_per_user"] = self.max_clusters_per_user
-        if self.name is not None:
-            body["name"] = self.name
-        if self.policy_family_definition_overrides is not None:
-            body["policy_family_definition_overrides"] = self.policy_family_definition_overrides
-        if self.policy_family_id is not None:
-            body["policy_family_id"] = self.policy_family_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreatePolicy into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.definition is not None:
-            body["definition"] = self.definition
-        if self.description is not None:
-            body["description"] = self.description
-        if self.libraries:
-            body["libraries"] = self.libraries
-        if self.max_clusters_per_user is not None:
-            body["max_clusters_per_user"] = self.max_clusters_per_user
-        if self.name is not None:
-            body["name"] = self.name
-        if self.policy_family_definition_overrides is not None:
-            body["policy_family_definition_overrides"] = self.policy_family_definition_overrides
-        if self.policy_family_id is not None:
-            body["policy_family_id"] = self.policy_family_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreatePolicy:
-        """Deserializes the CreatePolicy from a dictionary."""
-        return cls(
-            definition=d.get("definition", None),
-            description=d.get("description", None),
-            libraries=_repeated_dict(d, "libraries", Library),
-            max_clusters_per_user=d.get("max_clusters_per_user", None),
-            name=d.get("name", None),
-            policy_family_definition_overrides=d.get("policy_family_definition_overrides", None),
-            policy_family_id=d.get("policy_family_id", None),
-        )
-
-
-@dataclass
-class CreatePolicyResponse:
-    policy_id: Optional[str] = None
-    """Canonical unique identifier for the cluster policy."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreatePolicyResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.policy_id is not None:
-            body["policy_id"] = self.policy_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreatePolicyResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.policy_id is not None:
-            body["policy_id"] = self.policy_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreatePolicyResponse:
-        """Deserializes the CreatePolicyResponse from a dictionary."""
-        return cls(policy_id=d.get("policy_id", None))
-
-
-@dataclass
-class CreateResponse:
-    script_id: Optional[str] = None
-    """The global init script ID."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.script_id is not None:
-            body["script_id"] = self.script_id
-        return body
+    Disks will be mounted at: - For AWS: `/ebs0`, `/ebs1`, and etc. - For Azure: `/remote_volume0`,
+    `/remote_volume1`, and etc."""
 
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.script_id is not None:
-            body["script_id"] = self.script_id
-        return body
+    disk_iops: Optional[int] = None
 
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateResponse:
-        """Deserializes the CreateResponse from a dictionary."""
-        return cls(script_id=d.get("script_id", None))
-
-
-@dataclass
-class Created:
-    id: Optional[str] = None
-
-    def as_dict(self) -> dict:
-        """Serializes the Created into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.id is not None:
-            body["id"] = self.id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the Created into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.id is not None:
-            body["id"] = self.id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> Created:
-        """Deserializes the Created from a dictionary."""
-        return cls(id=d.get("id", None))
-
-
-@dataclass
-class CustomPolicyTag:
-    key: str
-    """The key of the tag. - Must be unique among all custom tags of the same policy - Cannot be
-    “budget-policy-name”, “budget-policy-id” or "budget-policy-resolution-result" - these
-    tags are preserved."""
-
-    value: Optional[str] = None
-    """The value of the tag."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CustomPolicyTag into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.key is not None:
-            body["key"] = self.key
-        if self.value is not None:
-            body["value"] = self.value
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CustomPolicyTag into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.key is not None:
-            body["key"] = self.key
-        if self.value is not None:
-            body["value"] = self.value
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CustomPolicyTag:
-        """Deserializes the CustomPolicyTag from a dictionary."""
-        return cls(key=d.get("key", None), value=d.get("value", None))
-
-
-@dataclass
-class DataPlaneEventDetails:
-    event_type: Optional[DataPlaneEventDetailsEventType] = None
-
-    executor_failures: Optional[int] = None
-
-    host_id: Optional[str] = None
-
-    timestamp: Optional[int] = None
-
-    def as_dict(self) -> dict:
-        """Serializes the DataPlaneEventDetails into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.event_type is not None:
-            body["event_type"] = self.event_type.value
-        if self.executor_failures is not None:
-            body["executor_failures"] = self.executor_failures
-        if self.host_id is not None:
-            body["host_id"] = self.host_id
-        if self.timestamp is not None:
-            body["timestamp"] = self.timestamp
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DataPlaneEventDetails into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.event_type is not None:
-            body["event_type"] = self.event_type
-        if self.executor_failures is not None:
-            body["executor_failures"] = self.executor_failures
-        if self.host_id is not None:
-            body["host_id"] = self.host_id
-        if self.timestamp is not None:
-            body["timestamp"] = self.timestamp
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DataPlaneEventDetails:
-        """Deserializes the DataPlaneEventDetails from a dictionary."""
-        return cls(
-            event_type=_enum(d, "event_type", DataPlaneEventDetailsEventType),
-            executor_failures=d.get("executor_failures", None),
-            host_id=d.get("host_id", None),
-            timestamp=d.get("timestamp", None),
-        )
-
-
-class DataPlaneEventDetailsEventType(Enum):
-
-    NODE_BLACKLISTED = "NODE_BLACKLISTED"
-    NODE_EXCLUDED_DECOMMISSIONED = "NODE_EXCLUDED_DECOMMISSIONED"
-
-
-class DataSecurityMode(Enum):
-    """Data security mode decides what data governance model to use when accessing data from a cluster.
-
-    The following modes can only be used when `kind = CLASSIC_PREVIEW`. * `DATA_SECURITY_MODE_AUTO`:
-    Databricks will choose the most appropriate access mode depending on your compute configuration.
-    * `DATA_SECURITY_MODE_STANDARD`: Alias for `USER_ISOLATION`. * `DATA_SECURITY_MODE_DEDICATED`:
-    Alias for `SINGLE_USER`.
-
-    The following modes can be used regardless of `kind`. * `NONE`: No security isolation for
-    multiple users sharing the cluster. Data governance features are not available in this mode. *
-    `SINGLE_USER`: A secure cluster that can only be exclusively used by a single user specified in
-    `single_user_name`. Most programming languages, cluster features and data governance features
-    are available in this mode. * `USER_ISOLATION`: A secure cluster that can be shared by multiple
-    users. Cluster users are fully isolated so that they cannot see each other's data and
-    credentials. Most data governance features are supported in this mode. But programming languages
-    and cluster features might be limited.
-
-    The following modes are deprecated starting with Databricks Runtime 15.0 and will be removed for
-    future Databricks Runtime versions:
-
-    * `LEGACY_TABLE_ACL`: This mode is for users migrating from legacy Table ACL clusters. *
-    `LEGACY_PASSTHROUGH`: This mode is for users migrating from legacy Passthrough on high
-    concurrency clusters. * `LEGACY_SINGLE_USER`: This mode is for users migrating from legacy
-    Passthrough on standard clusters. * `LEGACY_SINGLE_USER_STANDARD`: This mode provides a way that
-    doesn’t have UC nor passthrough enabled."""
-
-    DATA_SECURITY_MODE_AUTO = "DATA_SECURITY_MODE_AUTO"
-    DATA_SECURITY_MODE_DEDICATED = "DATA_SECURITY_MODE_DEDICATED"
-    DATA_SECURITY_MODE_STANDARD = "DATA_SECURITY_MODE_STANDARD"
-    LEGACY_PASSTHROUGH = "LEGACY_PASSTHROUGH"
-    LEGACY_SINGLE_USER = "LEGACY_SINGLE_USER"
-    LEGACY_SINGLE_USER_STANDARD = "LEGACY_SINGLE_USER_STANDARD"
-    LEGACY_TABLE_ACL = "LEGACY_TABLE_ACL"
-    NONE = "NONE"
-    SINGLE_USER = "SINGLE_USER"
-    USER_ISOLATION = "USER_ISOLATION"
-
-
-@dataclass
-class DbfsStorageInfo:
-    """A storage location in DBFS"""
-
-    destination: str
-    """dbfs destination, e.g. `dbfs:/my/path`"""
-
-    def as_dict(self) -> dict:
-        """Serializes the DbfsStorageInfo into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.destination is not None:
-            body["destination"] = self.destination
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DbfsStorageInfo into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.destination is not None:
-            body["destination"] = self.destination
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DbfsStorageInfo:
-        """Deserializes the DbfsStorageInfo from a dictionary."""
-        return cls(destination=d.get("destination", None))
-
-
-@dataclass
-class DeleteCluster:
-    cluster_id: str
-    """The cluster to be terminated."""
-
-    def as_dict(self) -> dict:
-        """Serializes the DeleteCluster into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DeleteCluster into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DeleteCluster:
-        """Deserializes the DeleteCluster from a dictionary."""
-        return cls(cluster_id=d.get("cluster_id", None))
-
-
-@dataclass
-class DeleteClusterResponse:
-    def as_dict(self) -> dict:
-        """Serializes the DeleteClusterResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DeleteClusterResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DeleteClusterResponse:
-        """Deserializes the DeleteClusterResponse from a dictionary."""
-        return cls()
-
-
-@dataclass
-class DeleteInstancePool:
-    instance_pool_id: str
-    """The instance pool to be terminated."""
-
-    def as_dict(self) -> dict:
-        """Serializes the DeleteInstancePool into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.instance_pool_id is not None:
-            body["instance_pool_id"] = self.instance_pool_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DeleteInstancePool into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.instance_pool_id is not None:
-            body["instance_pool_id"] = self.instance_pool_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DeleteInstancePool:
-        """Deserializes the DeleteInstancePool from a dictionary."""
-        return cls(instance_pool_id=d.get("instance_pool_id", None))
-
-
-@dataclass
-class DeleteInstancePoolResponse:
-    def as_dict(self) -> dict:
-        """Serializes the DeleteInstancePoolResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DeleteInstancePoolResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DeleteInstancePoolResponse:
-        """Deserializes the DeleteInstancePoolResponse from a dictionary."""
-        return cls()
-
-
-@dataclass
-class DeletePolicy:
-    policy_id: str
-    """The ID of the policy to delete."""
-
-    def as_dict(self) -> dict:
-        """Serializes the DeletePolicy into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.policy_id is not None:
-            body["policy_id"] = self.policy_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DeletePolicy into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.policy_id is not None:
-            body["policy_id"] = self.policy_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DeletePolicy:
-        """Deserializes the DeletePolicy from a dictionary."""
-        return cls(policy_id=d.get("policy_id", None))
-
-
-@dataclass
-class DeletePolicyResponse:
-    def as_dict(self) -> dict:
-        """Serializes the DeletePolicyResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DeletePolicyResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DeletePolicyResponse:
-        """Deserializes the DeletePolicyResponse from a dictionary."""
-        return cls()
-
-
-@dataclass
-class DeleteResponse:
-    def as_dict(self) -> dict:
-        """Serializes the DeleteResponse into a dictionary suitable for use as a JSON request body."""
-        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 DestroyContext:
-    cluster_id: str
-
-    context_id: str
-
-    def as_dict(self) -> dict:
-        """Serializes the DestroyContext into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.cluster_id is not None:
-            body["clusterId"] = self.cluster_id
-        if self.context_id is not None:
-            body["contextId"] = self.context_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DestroyContext into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.cluster_id is not None:
-            body["clusterId"] = self.cluster_id
-        if self.context_id is not None:
-            body["contextId"] = self.context_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DestroyContext:
-        """Deserializes the DestroyContext from a dictionary."""
-        return cls(cluster_id=d.get("clusterId", None), context_id=d.get("contextId", None))
-
-
-@dataclass
-class DestroyResponse:
-    def as_dict(self) -> dict:
-        """Serializes the DestroyResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DestroyResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DestroyResponse:
-        """Deserializes the DestroyResponse from a dictionary."""
-        return cls()
-
-
-@dataclass
-class DiskSpec:
-    """Describes the disks that are launched for each instance in the spark cluster. For example, if
-    the cluster has 3 instances, each instance is configured to launch 2 disks, 100 GiB each, then
-    Databricks will launch a total of 6 disks, 100 GiB each, for this cluster."""
-
-    disk_count: Optional[int] = None
-    """The number of disks launched for each instance: - This feature is only enabled for supported
-    node types. - Users can choose up to the limit of the disks supported by the node type. - For
-    node types with no OS disk, at least one disk must be specified; otherwise, cluster creation
-    will fail.
-    
-    If disks are attached, Databricks will configure Spark to use only the disks for scratch
-    storage, because heterogenously sized scratch devices can lead to inefficient disk utilization.
-    If no disks are attached, Databricks will configure Spark to use instance store disks.
-    
-    Note: If disks are specified, then the Spark configuration `spark.local.dir` will be overridden.
-    
-    Disks will be mounted at: - For AWS: `/ebs0`, `/ebs1`, and etc. - For Azure: `/remote_volume0`,
-    `/remote_volume1`, and etc."""
-
-    disk_iops: Optional[int] = None
-
-    disk_size: Optional[int] = None
-    """The size of each disk (in GiB) launched for each instance. Values must fall into the supported
-    range for a particular instance type.
-    
-    For AWS: - General Purpose SSD: 100 - 4096 GiB - Throughput Optimized HDD: 500 - 4096 GiB
-    
-    For Azure: - Premium LRS (SSD): 1 - 1023 GiB - Standard LRS (HDD): 1- 1023 GiB"""
-
-    disk_throughput: Optional[int] = None
-
-    disk_type: Optional[DiskType] = None
-    """The type of disks that will be launched with this cluster."""
-
-    def as_dict(self) -> dict:
-        """Serializes the DiskSpec into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.disk_count is not None:
-            body["disk_count"] = self.disk_count
-        if self.disk_iops is not None:
-            body["disk_iops"] = self.disk_iops
-        if self.disk_size is not None:
-            body["disk_size"] = self.disk_size
-        if self.disk_throughput is not None:
-            body["disk_throughput"] = self.disk_throughput
-        if self.disk_type:
-            body["disk_type"] = self.disk_type.as_dict()
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DiskSpec into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.disk_count is not None:
-            body["disk_count"] = self.disk_count
-        if self.disk_iops is not None:
-            body["disk_iops"] = self.disk_iops
-        if self.disk_size is not None:
-            body["disk_size"] = self.disk_size
-        if self.disk_throughput is not None:
-            body["disk_throughput"] = self.disk_throughput
-        if self.disk_type:
-            body["disk_type"] = self.disk_type
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DiskSpec:
-        """Deserializes the DiskSpec from a dictionary."""
-        return cls(
-            disk_count=d.get("disk_count", None),
-            disk_iops=d.get("disk_iops", None),
-            disk_size=d.get("disk_size", None),
-            disk_throughput=d.get("disk_throughput", None),
-            disk_type=_from_dict(d, "disk_type", DiskType),
-        )
-
-
-@dataclass
-class DiskType:
-    """Describes the disk type."""
-
-    azure_disk_volume_type: Optional[DiskTypeAzureDiskVolumeType] = None
-
-    ebs_volume_type: Optional[DiskTypeEbsVolumeType] = None
-
-    def as_dict(self) -> dict:
-        """Serializes the DiskType into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.azure_disk_volume_type is not None:
-            body["azure_disk_volume_type"] = self.azure_disk_volume_type.value
-        if self.ebs_volume_type is not None:
-            body["ebs_volume_type"] = self.ebs_volume_type.value
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DiskType into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.azure_disk_volume_type is not None:
-            body["azure_disk_volume_type"] = self.azure_disk_volume_type
-        if self.ebs_volume_type is not None:
-            body["ebs_volume_type"] = self.ebs_volume_type
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DiskType:
-        """Deserializes the DiskType from a dictionary."""
-        return cls(
-            azure_disk_volume_type=_enum(d, "azure_disk_volume_type", DiskTypeAzureDiskVolumeType),
-            ebs_volume_type=_enum(d, "ebs_volume_type", DiskTypeEbsVolumeType),
-        )
-
-
-class DiskTypeAzureDiskVolumeType(Enum):
-    """All Azure Disk types that Databricks supports. See
-    https://docs.microsoft.com/en-us/azure/storage/storage-about-disks-and-vhds-linux#types-of-disks"""
-
-    PREMIUM_LRS = "PREMIUM_LRS"
-    STANDARD_LRS = "STANDARD_LRS"
-
-
-class DiskTypeEbsVolumeType(Enum):
-    """All EBS volume types that Databricks supports. See https://aws.amazon.com/ebs/details/ for
-    details."""
-
-    GENERAL_PURPOSE_SSD = "GENERAL_PURPOSE_SSD"
-    THROUGHPUT_OPTIMIZED_HDD = "THROUGHPUT_OPTIMIZED_HDD"
-
-
-@dataclass
-class DockerBasicAuth:
-    password: Optional[str] = None
-    """Password of the user"""
-
-    username: Optional[str] = None
-    """Name of the user"""
-
-    def as_dict(self) -> dict:
-        """Serializes the DockerBasicAuth into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.password is not None:
-            body["password"] = self.password
-        if self.username is not None:
-            body["username"] = self.username
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DockerBasicAuth into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.password is not None:
-            body["password"] = self.password
-        if self.username is not None:
-            body["username"] = self.username
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DockerBasicAuth:
-        """Deserializes the DockerBasicAuth from a dictionary."""
-        return cls(password=d.get("password", None), username=d.get("username", None))
-
-
-@dataclass
-class DockerImage:
-    basic_auth: Optional[DockerBasicAuth] = None
-    """Basic auth with username and password"""
-
-    url: Optional[str] = None
-    """URL of the docker image."""
-
-    def as_dict(self) -> dict:
-        """Serializes the DockerImage into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.basic_auth:
-            body["basic_auth"] = self.basic_auth.as_dict()
-        if self.url is not None:
-            body["url"] = self.url
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the DockerImage into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.basic_auth:
-            body["basic_auth"] = self.basic_auth
-        if self.url is not None:
-            body["url"] = self.url
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> DockerImage:
-        """Deserializes the DockerImage from a dictionary."""
-        return cls(basic_auth=_from_dict(d, "basic_auth", DockerBasicAuth), url=d.get("url", None))
-
-
-class EbsVolumeType(Enum):
-    """All EBS volume types that Databricks supports. See https://aws.amazon.com/ebs/details/ for
-    details."""
-
-    GENERAL_PURPOSE_SSD = "GENERAL_PURPOSE_SSD"
-    THROUGHPUT_OPTIMIZED_HDD = "THROUGHPUT_OPTIMIZED_HDD"
-
-
-@dataclass
-class EditCluster:
-    cluster_id: str
-    """ID of the cluster"""
-
-    spark_version: str
-    """The Spark version of the cluster, e.g. `3.3.x-scala2.11`. A list of available Spark versions can
-    be retrieved by using the :method:clusters/sparkVersions API call."""
-
-    apply_policy_default_values: Optional[bool] = None
-    """When set to true, fixed and default values from the policy will be used for fields that are
-    omitted. When set to false, only fixed values from the policy will be applied."""
-
-    autoscale: Optional[AutoScale] = None
-    """Parameters needed in order to automatically scale clusters up and down based on load. Note:
-    autoscaling works best with DB runtime versions 3.0 or later."""
-
-    autotermination_minutes: Optional[int] = None
-    """Automatically terminates the cluster after it is inactive for this time in minutes. If not set,
-    this cluster will not be automatically terminated. If specified, the threshold must be between
-    10 and 10000 minutes. Users can also set this value to 0 to explicitly disable automatic
-    termination."""
-
-    aws_attributes: Optional[AwsAttributes] = None
-    """Attributes related to clusters running on Amazon Web Services. If not specified at cluster
-    creation, a set of default values will be used."""
-
-    azure_attributes: Optional[AzureAttributes] = None
-    """Attributes related to clusters running on Microsoft Azure. If not specified at cluster creation,
-    a set of default values will be used."""
-
-    cluster_log_conf: Optional[ClusterLogConf] = None
-    """The configuration for delivering spark logs to a long-term storage destination. Three kinds of
-    destinations (DBFS, S3 and Unity Catalog volumes) are supported. Only one destination can be
-    specified for one cluster. If the conf is given, the logs will be delivered to the destination
-    every `5 mins`. The destination of driver logs is `$destination/$clusterId/driver`, while the
-    destination of executor logs is `$destination/$clusterId/executor`."""
-
-    cluster_name: Optional[str] = None
-    """Cluster name requested by the user. This doesn't have to be unique. If not specified at
-    creation, the cluster name will be an empty string. For job clusters, the cluster name is
-    automatically set based on the job and job run IDs."""
-
-    custom_tags: Optional[Dict[str, str]] = None
-    """Additional tags for cluster resources. Databricks will tag all cluster resources (e.g., AWS
-    instances and EBS volumes) with these tags in addition to `default_tags`. Notes:
-    
-    - Currently, Databricks allows at most 45 custom tags
-    
-    - Clusters can only reuse cloud resources if the resources' tags are a subset of the cluster
-    tags"""
-
-    data_security_mode: Optional[DataSecurityMode] = None
-
-    docker_image: Optional[DockerImage] = None
-    """Custom docker image BYOC"""
-
-    driver_instance_pool_id: Optional[str] = None
-    """The optional ID of the instance pool for the driver of the cluster belongs. The pool cluster
-    uses the instance pool with id (instance_pool_id) if the driver pool is not assigned."""
-
-    driver_node_type_id: Optional[str] = None
-    """The node type of the Spark driver. Note that this field is optional; if unset, the driver node
-    type will be set as the same value as `node_type_id` defined above.
-    
-    This field, along with node_type_id, should not be set if virtual_cluster_size is set. If both
-    driver_node_type_id, node_type_id, and virtual_cluster_size are specified, driver_node_type_id
-    and node_type_id take precedence."""
-
-    enable_elastic_disk: Optional[bool] = None
-    """Autoscaling Local Storage: when enabled, this cluster will dynamically acquire additional disk
-    space when its Spark workers are running low on disk space. This feature requires specific AWS
-    permissions to function correctly - refer to the User Guide for more details."""
-
-    enable_local_disk_encryption: Optional[bool] = None
-    """Whether to enable LUKS on cluster VMs' local disks"""
-
-    gcp_attributes: Optional[GcpAttributes] = None
-    """Attributes related to clusters running on Google Cloud Platform. If not specified at cluster
-    creation, a set of default values will be used."""
-
-    init_scripts: Optional[List[InitScriptInfo]] = None
-    """The configuration for storing init scripts. Any number of destinations can be specified. The
-    scripts are executed sequentially in the order provided. If `cluster_log_conf` is specified,
-    init script logs are sent to `<destination>/<cluster-ID>/init_scripts`."""
-
-    instance_pool_id: Optional[str] = None
-    """The optional ID of the instance pool to which the cluster belongs."""
-
-    is_single_node: Optional[bool] = None
-    """This field can only be used when `kind = CLASSIC_PREVIEW`.
-    
-    When set to true, Databricks will automatically set single node related `custom_tags`,
-    `spark_conf`, and `num_workers`"""
-
-    kind: Optional[Kind] = None
-
-    node_type_id: Optional[str] = None
-    """This field encodes, through a single value, the resources available to each of the Spark nodes
-    in this cluster. For example, the Spark nodes can be provisioned and optimized for memory or
-    compute intensive workloads. A list of available node types can be retrieved by using the
-    :method:clusters/listNodeTypes API call."""
-
-    num_workers: Optional[int] = None
-    """Number of worker nodes that this cluster should have. A cluster has one Spark Driver and
-    `num_workers` Executors for a total of `num_workers` + 1 Spark nodes.
-    
-    Note: When reading the properties of a cluster, this field reflects the desired number of
-    workers rather than the actual current number of workers. For instance, if a cluster is resized
-    from 5 to 10 workers, this field will immediately be updated to reflect the target size of 10
-    workers, whereas the workers listed in `spark_info` will gradually increase from 5 to 10 as the
-    new nodes are provisioned."""
-
-    policy_id: Optional[str] = None
-    """The ID of the cluster policy used to create the cluster if applicable."""
-
-    remote_disk_throughput: Optional[int] = None
-    """If set, what the configurable throughput (in Mb/s) for the remote disk is. Currently only
-    supported for GCP HYPERDISK_BALANCED disks."""
-
-    runtime_engine: Optional[RuntimeEngine] = None
-    """Determines the cluster's runtime engine, either standard or Photon.
-    
-    This field is not compatible with legacy `spark_version` values that contain `-photon-`. Remove
-    `-photon-` from the `spark_version` and set `runtime_engine` to `PHOTON`.
-    
-    If left unspecified, the runtime engine defaults to standard unless the spark_version contains
-    -photon-, in which case Photon will be used."""
-
-    single_user_name: Optional[str] = None
-    """Single user name if data_security_mode is `SINGLE_USER`"""
-
-    spark_conf: Optional[Dict[str, str]] = None
-    """An object containing a set of optional, user-specified Spark configuration key-value pairs.
-    Users can also pass in a string of extra JVM options to the driver and the executors via
-    `spark.driver.extraJavaOptions` and `spark.executor.extraJavaOptions` respectively."""
-
-    spark_env_vars: Optional[Dict[str, str]] = None
-    """An object containing a set of optional, user-specified environment variable key-value pairs.
-    Please note that key-value pair of the form (X,Y) will be exported as is (i.e., `export X='Y'`)
-    while launching the driver and workers.
-    
-    In order to specify an additional set of `SPARK_DAEMON_JAVA_OPTS`, we recommend appending them
-    to `$SPARK_DAEMON_JAVA_OPTS` as shown in the example below. This ensures that all default
-    databricks managed environmental variables are included as well.
-    
-    Example Spark environment variables: `{"SPARK_WORKER_MEMORY": "28000m", "SPARK_LOCAL_DIRS":
-    "/local_disk0"}` or `{"SPARK_DAEMON_JAVA_OPTS": "$SPARK_DAEMON_JAVA_OPTS
-    -Dspark.shuffle.service.enabled=true"}`"""
-
-    ssh_public_keys: Optional[List[str]] = None
-    """SSH public key contents that will be added to each Spark node in this cluster. The corresponding
-    private keys can be used to login with the user name `ubuntu` on port `2200`. Up to 10 keys can
-    be specified."""
-
-    total_initial_remote_disk_size: Optional[int] = None
-    """If set, what the total initial volume size (in GB) of the remote disks should be. Currently only
-    supported for GCP HYPERDISK_BALANCED disks."""
-
-    use_ml_runtime: Optional[bool] = None
-    """This field can only be used when `kind = CLASSIC_PREVIEW`.
-    
-    `effective_spark_version` is determined by `spark_version` (DBR release), this field
-    `use_ml_runtime`, and whether `node_type_id` is gpu node or not."""
-
-    workload_type: Optional[WorkloadType] = None
-
-    def as_dict(self) -> dict:
-        """Serializes the EditCluster into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.apply_policy_default_values is not None:
-            body["apply_policy_default_values"] = self.apply_policy_default_values
-        if self.autoscale:
-            body["autoscale"] = self.autoscale.as_dict()
-        if self.autotermination_minutes is not None:
-            body["autotermination_minutes"] = self.autotermination_minutes
-        if self.aws_attributes:
-            body["aws_attributes"] = self.aws_attributes.as_dict()
-        if self.azure_attributes:
-            body["azure_attributes"] = self.azure_attributes.as_dict()
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        if self.cluster_log_conf:
-            body["cluster_log_conf"] = self.cluster_log_conf.as_dict()
-        if self.cluster_name is not None:
-            body["cluster_name"] = self.cluster_name
-        if self.custom_tags:
-            body["custom_tags"] = self.custom_tags
-        if self.data_security_mode is not None:
-            body["data_security_mode"] = self.data_security_mode.value
-        if self.docker_image:
-            body["docker_image"] = self.docker_image.as_dict()
-        if self.driver_instance_pool_id is not None:
-            body["driver_instance_pool_id"] = self.driver_instance_pool_id
-        if self.driver_node_type_id is not None:
-            body["driver_node_type_id"] = self.driver_node_type_id
-        if self.enable_elastic_disk is not None:
-            body["enable_elastic_disk"] = self.enable_elastic_disk
-        if self.enable_local_disk_encryption is not None:
-            body["enable_local_disk_encryption"] = self.enable_local_disk_encryption
-        if self.gcp_attributes:
-            body["gcp_attributes"] = self.gcp_attributes.as_dict()
-        if self.init_scripts:
-            body["init_scripts"] = [v.as_dict() for v in self.init_scripts]
-        if self.instance_pool_id is not None:
-            body["instance_pool_id"] = self.instance_pool_id
-        if self.is_single_node is not None:
-            body["is_single_node"] = self.is_single_node
-        if self.kind is not None:
-            body["kind"] = self.kind.value
-        if self.node_type_id is not None:
-            body["node_type_id"] = self.node_type_id
-        if self.num_workers is not None:
-            body["num_workers"] = self.num_workers
-        if self.policy_id is not None:
-            body["policy_id"] = self.policy_id
-        if self.remote_disk_throughput is not None:
-            body["remote_disk_throughput"] = self.remote_disk_throughput
-        if self.runtime_engine is not None:
-            body["runtime_engine"] = self.runtime_engine.value
-        if self.single_user_name is not None:
-            body["single_user_name"] = self.single_user_name
-        if self.spark_conf:
-            body["spark_conf"] = self.spark_conf
-        if self.spark_env_vars:
-            body["spark_env_vars"] = self.spark_env_vars
-        if self.spark_version is not None:
-            body["spark_version"] = self.spark_version
-        if self.ssh_public_keys:
-            body["ssh_public_keys"] = [v for v in self.ssh_public_keys]
-        if self.total_initial_remote_disk_size is not None:
-            body["total_initial_remote_disk_size"] = self.total_initial_remote_disk_size
-        if self.use_ml_runtime is not None:
-            body["use_ml_runtime"] = self.use_ml_runtime
-        if self.workload_type:
-            body["workload_type"] = self.workload_type.as_dict()
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the EditCluster into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.apply_policy_default_values is not None:
-            body["apply_policy_default_values"] = self.apply_policy_default_values
-        if self.autoscale:
-            body["autoscale"] = self.autoscale
-        if self.autotermination_minutes is not None:
-            body["autotermination_minutes"] = self.autotermination_minutes
-        if self.aws_attributes:
-            body["aws_attributes"] = self.aws_attributes
-        if self.azure_attributes:
-            body["azure_attributes"] = self.azure_attributes
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        if self.cluster_log_conf:
-            body["cluster_log_conf"] = self.cluster_log_conf
-        if self.cluster_name is not None:
-            body["cluster_name"] = self.cluster_name
-        if self.custom_tags:
-            body["custom_tags"] = self.custom_tags
-        if self.data_security_mode is not None:
-            body["data_security_mode"] = self.data_security_mode
-        if self.docker_image:
-            body["docker_image"] = self.docker_image
-        if self.driver_instance_pool_id is not None:
-            body["driver_instance_pool_id"] = self.driver_instance_pool_id
-        if self.driver_node_type_id is not None:
-            body["driver_node_type_id"] = self.driver_node_type_id
-        if self.enable_elastic_disk is not None:
-            body["enable_elastic_disk"] = self.enable_elastic_disk
-        if self.enable_local_disk_encryption is not None:
-            body["enable_local_disk_encryption"] = self.enable_local_disk_encryption
-        if self.gcp_attributes:
-            body["gcp_attributes"] = self.gcp_attributes
-        if self.init_scripts:
-            body["init_scripts"] = self.init_scripts
-        if self.instance_pool_id is not None:
-            body["instance_pool_id"] = self.instance_pool_id
-        if self.is_single_node is not None:
-            body["is_single_node"] = self.is_single_node
-        if self.kind is not None:
-            body["kind"] = self.kind
-        if self.node_type_id is not None:
-            body["node_type_id"] = self.node_type_id
-        if self.num_workers is not None:
-            body["num_workers"] = self.num_workers
-        if self.policy_id is not None:
-            body["policy_id"] = self.policy_id
-        if self.remote_disk_throughput is not None:
-            body["remote_disk_throughput"] = self.remote_disk_throughput
-        if self.runtime_engine is not None:
-            body["runtime_engine"] = self.runtime_engine
-        if self.single_user_name is not None:
-            body["single_user_name"] = self.single_user_name
-        if self.spark_conf:
-            body["spark_conf"] = self.spark_conf
-        if self.spark_env_vars:
-            body["spark_env_vars"] = self.spark_env_vars
-        if self.spark_version is not None:
-            body["spark_version"] = self.spark_version
-        if self.ssh_public_keys:
-            body["ssh_public_keys"] = self.ssh_public_keys
-        if self.total_initial_remote_disk_size is not None:
-            body["total_initial_remote_disk_size"] = self.total_initial_remote_disk_size
-        if self.use_ml_runtime is not None:
-            body["use_ml_runtime"] = self.use_ml_runtime
-        if self.workload_type:
-            body["workload_type"] = self.workload_type
+    disk_size: Optional[int] = None
+    """The size of each disk (in GiB) launched for each instance. Values must fall into the supported
+    range for a particular instance type.
+    
+    For AWS: - General Purpose SSD: 100 - 4096 GiB - Throughput Optimized HDD: 500 - 4096 GiB
+    
+    For Azure: - Premium LRS (SSD): 1 - 1023 GiB - Standard LRS (HDD): 1- 1023 GiB"""
+
+    disk_throughput: Optional[int] = None
+
+    disk_type: Optional[DiskType] = None
+    """The type of disks that will be launched with this cluster."""
+
+    def as_dict(self) -> dict:
+        """Serializes the DiskSpec into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.disk_count is not None:
+            body["disk_count"] = self.disk_count
+        if self.disk_iops is not None:
+            body["disk_iops"] = self.disk_iops
+        if self.disk_size is not None:
+            body["disk_size"] = self.disk_size
+        if self.disk_throughput is not None:
+            body["disk_throughput"] = self.disk_throughput
+        if self.disk_type:
+            body["disk_type"] = self.disk_type.as_dict()
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DiskSpec into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.disk_count is not None:
+            body["disk_count"] = self.disk_count
+        if self.disk_iops is not None:
+            body["disk_iops"] = self.disk_iops
+        if self.disk_size is not None:
+            body["disk_size"] = self.disk_size
+        if self.disk_throughput is not None:
+            body["disk_throughput"] = self.disk_throughput
+        if self.disk_type:
+            body["disk_type"] = self.disk_type
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> EditCluster:
-        """Deserializes the EditCluster from a dictionary."""
+    def from_dict(cls, d: Dict[str, Any]) -> DiskSpec:
+        """Deserializes the DiskSpec from a dictionary."""
         return cls(
-            apply_policy_default_values=d.get("apply_policy_default_values", None),
-            autoscale=_from_dict(d, "autoscale", AutoScale),
-            autotermination_minutes=d.get("autotermination_minutes", None),
-            aws_attributes=_from_dict(d, "aws_attributes", AwsAttributes),
-            azure_attributes=_from_dict(d, "azure_attributes", AzureAttributes),
-            cluster_id=d.get("cluster_id", None),
-            cluster_log_conf=_from_dict(d, "cluster_log_conf", ClusterLogConf),
-            cluster_name=d.get("cluster_name", None),
-            custom_tags=d.get("custom_tags", None),
-            data_security_mode=_enum(d, "data_security_mode", DataSecurityMode),
-            docker_image=_from_dict(d, "docker_image", DockerImage),
-            driver_instance_pool_id=d.get("driver_instance_pool_id", None),
-            driver_node_type_id=d.get("driver_node_type_id", None),
-            enable_elastic_disk=d.get("enable_elastic_disk", None),
-            enable_local_disk_encryption=d.get("enable_local_disk_encryption", None),
-            gcp_attributes=_from_dict(d, "gcp_attributes", GcpAttributes),
-            init_scripts=_repeated_dict(d, "init_scripts", InitScriptInfo),
-            instance_pool_id=d.get("instance_pool_id", None),
-            is_single_node=d.get("is_single_node", None),
-            kind=_enum(d, "kind", Kind),
-            node_type_id=d.get("node_type_id", None),
-            num_workers=d.get("num_workers", None),
-            policy_id=d.get("policy_id", None),
-            remote_disk_throughput=d.get("remote_disk_throughput", None),
-            runtime_engine=_enum(d, "runtime_engine", RuntimeEngine),
-            single_user_name=d.get("single_user_name", None),
-            spark_conf=d.get("spark_conf", None),
-            spark_env_vars=d.get("spark_env_vars", None),
-            spark_version=d.get("spark_version", None),
-            ssh_public_keys=d.get("ssh_public_keys", None),
-            total_initial_remote_disk_size=d.get("total_initial_remote_disk_size", None),
-            use_ml_runtime=d.get("use_ml_runtime", None),
-            workload_type=_from_dict(d, "workload_type", WorkloadType),
+            disk_count=d.get("disk_count", None),
+            disk_iops=d.get("disk_iops", None),
+            disk_size=d.get("disk_size", None),
+            disk_throughput=d.get("disk_throughput", None),
+            disk_type=_from_dict(d, "disk_type", DiskType),
         )
 
 
 @dataclass
-class EditClusterResponse:
+class DiskType:
+    """Describes the disk type."""
+
+    azure_disk_volume_type: Optional[DiskTypeAzureDiskVolumeType] = None
+
+    ebs_volume_type: Optional[DiskTypeEbsVolumeType] = None
+
     def as_dict(self) -> dict:
-        """Serializes the EditClusterResponse into a dictionary suitable for use as a JSON request body."""
+        """Serializes the DiskType into a dictionary suitable for use as a JSON request body."""
         body = {}
+        if self.azure_disk_volume_type is not None:
+            body["azure_disk_volume_type"] = self.azure_disk_volume_type.value
+        if self.ebs_volume_type is not None:
+            body["ebs_volume_type"] = self.ebs_volume_type.value
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the EditClusterResponse into a shallow dictionary of its immediate attributes."""
+        """Serializes the DiskType into a shallow dictionary of its immediate attributes."""
         body = {}
+        if self.azure_disk_volume_type is not None:
+            body["azure_disk_volume_type"] = self.azure_disk_volume_type
+        if self.ebs_volume_type is not None:
+            body["ebs_volume_type"] = self.ebs_volume_type
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> EditClusterResponse:
-        """Deserializes the EditClusterResponse from a dictionary."""
-        return cls()
+    def from_dict(cls, d: Dict[str, Any]) -> DiskType:
+        """Deserializes the DiskType from a dictionary."""
+        return cls(
+            azure_disk_volume_type=_enum(d, "azure_disk_volume_type", DiskTypeAzureDiskVolumeType),
+            ebs_volume_type=_enum(d, "ebs_volume_type", DiskTypeEbsVolumeType),
+        )
 
 
-@dataclass
-class EditInstancePool:
-    instance_pool_id: str
-    """Instance pool ID"""
+class DiskTypeAzureDiskVolumeType(Enum):
+    """All Azure Disk types that Databricks supports. See
+    https://docs.microsoft.com/en-us/azure/storage/storage-about-disks-and-vhds-linux#types-of-disks"""
 
-    instance_pool_name: str
-    """Pool name requested by the user. Pool name must be unique. Length must be between 1 and 100
-    characters."""
+    PREMIUM_LRS = "PREMIUM_LRS"
+    STANDARD_LRS = "STANDARD_LRS"
 
-    node_type_id: str
-    """This field encodes, through a single value, the resources available to each of the Spark nodes
-    in this cluster. For example, the Spark nodes can be provisioned and optimized for memory or
-    compute intensive workloads. A list of available node types can be retrieved by using the
-    :method:clusters/listNodeTypes API call."""
 
-    custom_tags: Optional[Dict[str, str]] = None
-    """Additional tags for pool resources. Databricks will tag all pool resources (e.g., AWS instances
-    and EBS volumes) with these tags in addition to `default_tags`. Notes:
-    
-    - Currently, Databricks allows at most 45 custom tags"""
+class DiskTypeEbsVolumeType(Enum):
+    """All EBS volume types that Databricks supports. See https://aws.amazon.com/ebs/details/ for
+    details."""
 
-    idle_instance_autotermination_minutes: Optional[int] = None
-    """Automatically terminates the extra instances in the pool cache after they are inactive for this
-    time in minutes if min_idle_instances requirement is already met. If not set, the extra pool
-    instances will be automatically terminated after a default timeout. If specified, the threshold
-    must be between 0 and 10000 minutes. Users can also set this value to 0 to instantly remove idle
-    instances from the cache if min cache size could still hold."""
+    GENERAL_PURPOSE_SSD = "GENERAL_PURPOSE_SSD"
+    THROUGHPUT_OPTIMIZED_HDD = "THROUGHPUT_OPTIMIZED_HDD"
 
-    max_capacity: Optional[int] = None
-    """Maximum number of outstanding instances to keep in the pool, including both instances used by
-    clusters and idle instances. Clusters that require further instance provisioning will fail
-    during upsize requests."""
 
-    min_idle_instances: Optional[int] = None
-    """Minimum number of idle instances to keep in the instance pool"""
+@dataclass
+class DockerBasicAuth:
+    password: Optional[str] = None
+    """Password of the user"""
 
-    remote_disk_throughput: Optional[int] = None
-    """If set, what the configurable throughput (in Mb/s) for the remote disk is. Currently only
-    supported for GCP HYPERDISK_BALANCED types."""
+    username: Optional[str] = None
+    """Name of the user"""
 
-    total_initial_remote_disk_size: Optional[int] = None
-    """If set, what the total initial volume size (in GB) of the remote disks should be. Currently only
-    supported for GCP HYPERDISK_BALANCED types."""
+    def as_dict(self) -> dict:
+        """Serializes the DockerBasicAuth into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.password is not None:
+            body["password"] = self.password
+        if self.username is not None:
+            body["username"] = self.username
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DockerBasicAuth into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.password is not None:
+            body["password"] = self.password
+        if self.username is not None:
+            body["username"] = self.username
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> DockerBasicAuth:
+        """Deserializes the DockerBasicAuth from a dictionary."""
+        return cls(password=d.get("password", None), username=d.get("username", None))
+
+
+@dataclass
+class DockerImage:
+    basic_auth: Optional[DockerBasicAuth] = None
+    """Basic auth with username and password"""
+
+    url: Optional[str] = None
+    """URL of the docker image."""
 
     def as_dict(self) -> dict:
-        """Serializes the EditInstancePool into a dictionary suitable for use as a JSON request body."""
+        """Serializes the DockerImage into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.custom_tags:
-            body["custom_tags"] = self.custom_tags
-        if self.idle_instance_autotermination_minutes is not None:
-            body["idle_instance_autotermination_minutes"] = self.idle_instance_autotermination_minutes
-        if self.instance_pool_id is not None:
-            body["instance_pool_id"] = self.instance_pool_id
-        if self.instance_pool_name is not None:
-            body["instance_pool_name"] = self.instance_pool_name
-        if self.max_capacity is not None:
-            body["max_capacity"] = self.max_capacity
-        if self.min_idle_instances is not None:
-            body["min_idle_instances"] = self.min_idle_instances
-        if self.node_type_id is not None:
-            body["node_type_id"] = self.node_type_id
-        if self.remote_disk_throughput is not None:
-            body["remote_disk_throughput"] = self.remote_disk_throughput
-        if self.total_initial_remote_disk_size is not None:
-            body["total_initial_remote_disk_size"] = self.total_initial_remote_disk_size
+        if self.basic_auth:
+            body["basic_auth"] = self.basic_auth.as_dict()
+        if self.url is not None:
+            body["url"] = self.url
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the EditInstancePool into a shallow dictionary of its immediate attributes."""
+        """Serializes the DockerImage into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.custom_tags:
-            body["custom_tags"] = self.custom_tags
-        if self.idle_instance_autotermination_minutes is not None:
-            body["idle_instance_autotermination_minutes"] = self.idle_instance_autotermination_minutes
-        if self.instance_pool_id is not None:
-            body["instance_pool_id"] = self.instance_pool_id
-        if self.instance_pool_name is not None:
-            body["instance_pool_name"] = self.instance_pool_name
-        if self.max_capacity is not None:
-            body["max_capacity"] = self.max_capacity
-        if self.min_idle_instances is not None:
-            body["min_idle_instances"] = self.min_idle_instances
-        if self.node_type_id is not None:
-            body["node_type_id"] = self.node_type_id
-        if self.remote_disk_throughput is not None:
-            body["remote_disk_throughput"] = self.remote_disk_throughput
-        if self.total_initial_remote_disk_size is not None:
-            body["total_initial_remote_disk_size"] = self.total_initial_remote_disk_size
+        if self.basic_auth:
+            body["basic_auth"] = self.basic_auth
+        if self.url is not None:
+            body["url"] = self.url
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> EditInstancePool:
-        """Deserializes the EditInstancePool from a dictionary."""
-        return cls(
-            custom_tags=d.get("custom_tags", None),
-            idle_instance_autotermination_minutes=d.get("idle_instance_autotermination_minutes", None),
-            instance_pool_id=d.get("instance_pool_id", None),
-            instance_pool_name=d.get("instance_pool_name", None),
-            max_capacity=d.get("max_capacity", None),
-            min_idle_instances=d.get("min_idle_instances", None),
-            node_type_id=d.get("node_type_id", None),
-            remote_disk_throughput=d.get("remote_disk_throughput", None),
-            total_initial_remote_disk_size=d.get("total_initial_remote_disk_size", None),
-        )
+    def from_dict(cls, d: Dict[str, Any]) -> DockerImage:
+        """Deserializes the DockerImage from a dictionary."""
+        return cls(basic_auth=_from_dict(d, "basic_auth", DockerBasicAuth), url=d.get("url", None))
+
+
+class EbsVolumeType(Enum):
+    """All EBS volume types that Databricks supports. See https://aws.amazon.com/ebs/details/ for
+    details."""
+
+    GENERAL_PURPOSE_SSD = "GENERAL_PURPOSE_SSD"
+    THROUGHPUT_OPTIMIZED_HDD = "THROUGHPUT_OPTIMIZED_HDD"
 
 
 @dataclass
-class EditInstancePoolResponse:
+class EditClusterResponse:
     def as_dict(self) -> dict:
-        """Serializes the EditInstancePoolResponse into a dictionary suitable for use as a JSON request body."""
+        """Serializes the EditClusterResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the EditInstancePoolResponse into a shallow dictionary of its immediate attributes."""
+        """Serializes the EditClusterResponse into a shallow dictionary of its immediate attributes."""
         body = {}
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> EditInstancePoolResponse:
-        """Deserializes the EditInstancePoolResponse from a dictionary."""
+    def from_dict(cls, d: Dict[str, Any]) -> EditClusterResponse:
+        """Deserializes the EditClusterResponse from a dictionary."""
         return cls()
 
 
 @dataclass
-class EditPolicy:
-    policy_id: str
-    """The ID of the policy to update."""
-
-    definition: Optional[str] = None
-    """Policy definition document expressed in [Databricks Cluster Policy Definition Language].
-    
-    [Databricks Cluster Policy Definition Language]: https://docs.databricks.com/administration-guide/clusters/policy-definition.html"""
-
-    description: Optional[str] = None
-    """Additional human-readable description of the cluster policy."""
-
-    libraries: Optional[List[Library]] = None
-    """A list of libraries to be installed on the next cluster restart that uses this policy. The
-    maximum number of libraries is 500."""
-
-    max_clusters_per_user: Optional[int] = None
-    """Max number of clusters per user that can be active using this policy. If not present, there is
-    no max limit."""
-
-    name: Optional[str] = None
-    """Cluster Policy name requested by the user. This has to be unique. Length must be between 1 and
-    100 characters."""
-
-    policy_family_definition_overrides: Optional[str] = None
-    """Policy definition JSON document expressed in [Databricks Policy Definition Language]. The JSON
-    document must be passed as a string and cannot be embedded in the requests.
-    
-    You can use this to customize the policy definition inherited from the policy family. Policy
-    rules specified here are merged into the inherited policy definition.
-    
-    [Databricks Policy Definition Language]: https://docs.databricks.com/administration-guide/clusters/policy-definition.html"""
-
-    policy_family_id: Optional[str] = None
-    """ID of the policy family. The cluster policy's policy definition inherits the policy family's
-    policy definition.
-    
-    Cannot be used with `definition`. Use `policy_family_definition_overrides` instead to customize
-    the policy definition."""
-
+class EditInstancePoolResponse:
     def as_dict(self) -> dict:
-        """Serializes the EditPolicy into a dictionary suitable for use as a JSON request body."""
+        """Serializes the EditInstancePoolResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.definition is not None:
-            body["definition"] = self.definition
-        if self.description is not None:
-            body["description"] = self.description
-        if self.libraries:
-            body["libraries"] = [v.as_dict() for v in self.libraries]
-        if self.max_clusters_per_user is not None:
-            body["max_clusters_per_user"] = self.max_clusters_per_user
-        if self.name is not None:
-            body["name"] = self.name
-        if self.policy_family_definition_overrides is not None:
-            body["policy_family_definition_overrides"] = self.policy_family_definition_overrides
-        if self.policy_family_id is not None:
-            body["policy_family_id"] = self.policy_family_id
-        if self.policy_id is not None:
-            body["policy_id"] = self.policy_id
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the EditPolicy into a shallow dictionary of its immediate attributes."""
+        """Serializes the EditInstancePoolResponse into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.definition is not None:
-            body["definition"] = self.definition
-        if self.description is not None:
-            body["description"] = self.description
-        if self.libraries:
-            body["libraries"] = self.libraries
-        if self.max_clusters_per_user is not None:
-            body["max_clusters_per_user"] = self.max_clusters_per_user
-        if self.name is not None:
-            body["name"] = self.name
-        if self.policy_family_definition_overrides is not None:
-            body["policy_family_definition_overrides"] = self.policy_family_definition_overrides
-        if self.policy_family_id is not None:
-            body["policy_family_id"] = self.policy_family_id
-        if self.policy_id is not None:
-            body["policy_id"] = self.policy_id
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> EditPolicy:
-        """Deserializes the EditPolicy from a dictionary."""
-        return cls(
-            definition=d.get("definition", None),
-            description=d.get("description", None),
-            libraries=_repeated_dict(d, "libraries", Library),
-            max_clusters_per_user=d.get("max_clusters_per_user", None),
-            name=d.get("name", None),
-            policy_family_definition_overrides=d.get("policy_family_definition_overrides", None),
-            policy_family_id=d.get("policy_family_id", None),
-            policy_id=d.get("policy_id", None),
-        )
+    def from_dict(cls, d: Dict[str, Any]) -> EditInstancePoolResponse:
+        """Deserializes the EditInstancePoolResponse from a dictionary."""
+        return cls()
 
 
 @dataclass
@@ -4625,39 +3081,6 @@ class EditResponse:
         return cls()
 
 
-@dataclass
-class EnforceClusterComplianceRequest:
-    cluster_id: str
-    """The ID of the cluster you want to enforce policy compliance on."""
-
-    validate_only: Optional[bool] = None
-    """If set, previews the changes that would be made to a cluster to enforce compliance but does not
-    update the cluster."""
-
-    def as_dict(self) -> dict:
-        """Serializes the EnforceClusterComplianceRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        if self.validate_only is not None:
-            body["validate_only"] = self.validate_only
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the EnforceClusterComplianceRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        if self.validate_only is not None:
-            body["validate_only"] = self.validate_only
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> EnforceClusterComplianceRequest:
-        """Deserializes the EnforceClusterComplianceRequest from a dictionary."""
-        return cls(cluster_id=d.get("cluster_id", None), validate_only=d.get("validate_only", None))
-
-
 @dataclass
 class EnforceClusterComplianceResponse:
     changes: Optional[List[ClusterSettingsChange]] = None
@@ -5613,65 +4036,6 @@ class GetSparkVersionsResponse:
         return cls(versions=_repeated_dict(d, "versions", SparkVersion))
 
 
-@dataclass
-class GlobalInitScriptCreateRequest:
-    name: str
-    """The name of the script"""
-
-    script: str
-    """The Base64-encoded content of the script."""
-
-    enabled: Optional[bool] = None
-    """Specifies whether the script is enabled. The script runs only if enabled."""
-
-    position: Optional[int] = None
-    """The position of a global init script, where 0 represents the first script to run, 1 is the
-    second script to run, in ascending order.
-    
-    If you omit the numeric position for a new global init script, it defaults to last position. It
-    will run after all current scripts. Setting any value greater than the position of the last
-    script is equivalent to the last position. Example: Take three existing scripts with positions
-    0, 1, and 2. Any position of (3) or greater puts the script in the last position. If an explicit
-    position value conflicts with an existing script value, your request succeeds, but the original
-    script at that position and all later scripts have their positions incremented by 1."""
-
-    def as_dict(self) -> dict:
-        """Serializes the GlobalInitScriptCreateRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.enabled is not None:
-            body["enabled"] = self.enabled
-        if self.name is not None:
-            body["name"] = self.name
-        if self.position is not None:
-            body["position"] = self.position
-        if self.script is not None:
-            body["script"] = self.script
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the GlobalInitScriptCreateRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.enabled is not None:
-            body["enabled"] = self.enabled
-        if self.name is not None:
-            body["name"] = self.name
-        if self.position is not None:
-            body["position"] = self.position
-        if self.script is not None:
-            body["script"] = self.script
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> GlobalInitScriptCreateRequest:
-        """Deserializes the GlobalInitScriptCreateRequest from a dictionary."""
-        return cls(
-            enabled=d.get("enabled", None),
-            name=d.get("name", None),
-            position=d.get("position", None),
-            script=d.get("script", None),
-        )
-
-
 @dataclass
 class GlobalInitScriptDetails:
     created_at: Optional[int] = None
@@ -5848,73 +4212,6 @@ class GlobalInitScriptDetailsWithContent:
         )
 
 
-@dataclass
-class GlobalInitScriptUpdateRequest:
-    name: str
-    """The name of the script"""
-
-    script: str
-    """The Base64-encoded content of the script."""
-
-    enabled: Optional[bool] = None
-    """Specifies whether the script is enabled. The script runs only if enabled."""
-
-    position: Optional[int] = None
-    """The position of a script, where 0 represents the first script to run, 1 is the second script to
-    run, in ascending order. To move the script to run first, set its position to 0.
-    
-    To move the script to the end, set its position to any value greater or equal to the position of
-    the last script. Example, three existing scripts with positions 0, 1, and 2. Any position value
-    of 2 or greater puts the script in the last position (2).
-    
-    If an explicit position value conflicts with an existing script, your request succeeds, but the
-    original script at that position and all later scripts have their positions incremented by 1."""
-
-    script_id: Optional[str] = None
-    """The ID of the global init script."""
-
-    def as_dict(self) -> dict:
-        """Serializes the GlobalInitScriptUpdateRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.enabled is not None:
-            body["enabled"] = self.enabled
-        if self.name is not None:
-            body["name"] = self.name
-        if self.position is not None:
-            body["position"] = self.position
-        if self.script is not None:
-            body["script"] = self.script
-        if self.script_id is not None:
-            body["script_id"] = self.script_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the GlobalInitScriptUpdateRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.enabled is not None:
-            body["enabled"] = self.enabled
-        if self.name is not None:
-            body["name"] = self.name
-        if self.position is not None:
-            body["position"] = self.position
-        if self.script is not None:
-            body["script"] = self.script
-        if self.script_id is not None:
-            body["script_id"] = self.script_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> GlobalInitScriptUpdateRequest:
-        """Deserializes the GlobalInitScriptUpdateRequest from a dictionary."""
-        return cls(
-            enabled=d.get("enabled", None),
-            name=d.get("name", None),
-            position=d.get("position", None),
-            script=d.get("script", None),
-            script_id=d.get("script_id", None),
-        )
-
-
 @dataclass
 class InitScriptEventDetails:
     cluster: Optional[List[InitScriptInfoAndExecutionDetails]] = None
@@ -6140,62 +4437,30 @@ class InitScriptInfoAndExecutionDetails:
         if self.gcs:
             body["gcs"] = self.gcs
         if self.s3:
-            body["s3"] = self.s3
-        if self.status is not None:
-            body["status"] = self.status
-        if self.volumes:
-            body["volumes"] = self.volumes
-        if self.workspace:
-            body["workspace"] = self.workspace
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> InitScriptInfoAndExecutionDetails:
-        """Deserializes the InitScriptInfoAndExecutionDetails from a dictionary."""
-        return cls(
-            abfss=_from_dict(d, "abfss", Adlsgen2Info),
-            dbfs=_from_dict(d, "dbfs", DbfsStorageInfo),
-            error_message=d.get("error_message", None),
-            execution_duration_seconds=d.get("execution_duration_seconds", None),
-            file=_from_dict(d, "file", LocalFileInfo),
-            gcs=_from_dict(d, "gcs", GcsStorageInfo),
-            s3=_from_dict(d, "s3", S3StorageInfo),
-            status=_enum(d, "status", InitScriptExecutionDetailsInitScriptExecutionStatus),
-            volumes=_from_dict(d, "volumes", VolumesStorageInfo),
-            workspace=_from_dict(d, "workspace", WorkspaceStorageInfo),
-        )
-
-
-@dataclass
-class InstallLibraries:
-    cluster_id: str
-    """Unique identifier for the cluster on which to install these libraries."""
-
-    libraries: List[Library]
-    """The libraries to install."""
-
-    def as_dict(self) -> dict:
-        """Serializes the InstallLibraries into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        if self.libraries:
-            body["libraries"] = [v.as_dict() for v in self.libraries]
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the InstallLibraries into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        if self.libraries:
-            body["libraries"] = self.libraries
+            body["s3"] = self.s3
+        if self.status is not None:
+            body["status"] = self.status
+        if self.volumes:
+            body["volumes"] = self.volumes
+        if self.workspace:
+            body["workspace"] = self.workspace
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> InstallLibraries:
-        """Deserializes the InstallLibraries from a dictionary."""
-        return cls(cluster_id=d.get("cluster_id", None), libraries=_repeated_dict(d, "libraries", Library))
+    def from_dict(cls, d: Dict[str, Any]) -> InitScriptInfoAndExecutionDetails:
+        """Deserializes the InitScriptInfoAndExecutionDetails from a dictionary."""
+        return cls(
+            abfss=_from_dict(d, "abfss", Adlsgen2Info),
+            dbfs=_from_dict(d, "dbfs", DbfsStorageInfo),
+            error_message=d.get("error_message", None),
+            execution_duration_seconds=d.get("execution_duration_seconds", None),
+            file=_from_dict(d, "file", LocalFileInfo),
+            gcs=_from_dict(d, "gcs", GcsStorageInfo),
+            s3=_from_dict(d, "s3", S3StorageInfo),
+            status=_enum(d, "status", InitScriptExecutionDetailsInitScriptExecutionStatus),
+            volumes=_from_dict(d, "volumes", VolumesStorageInfo),
+            workspace=_from_dict(d, "workspace", WorkspaceStorageInfo),
+        )
 
 
 @dataclass
@@ -6824,40 +5089,6 @@ class InstancePoolPermissionsDescription:
         )
 
 
-@dataclass
-class InstancePoolPermissionsRequest:
-    access_control_list: Optional[List[InstancePoolAccessControlRequest]] = None
-
-    instance_pool_id: Optional[str] = None
-    """The instance pool for which to get or manage permissions."""
-
-    def as_dict(self) -> dict:
-        """Serializes the InstancePoolPermissionsRequest 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.instance_pool_id is not None:
-            body["instance_pool_id"] = self.instance_pool_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the InstancePoolPermissionsRequest into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = self.access_control_list
-        if self.instance_pool_id is not None:
-            body["instance_pool_id"] = self.instance_pool_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> InstancePoolPermissionsRequest:
-        """Deserializes the InstancePoolPermissionsRequest from a dictionary."""
-        return cls(
-            access_control_list=_repeated_dict(d, "access_control_list", InstancePoolAccessControlRequest),
-            instance_pool_id=d.get("instance_pool_id", None),
-        )
-
-
 class InstancePoolState(Enum):
     """The state of a Cluster. The current allowable state transitions are as follows:
 
@@ -8017,31 +6248,6 @@ class PendingInstanceError:
         return cls(instance_id=d.get("instance_id", None), message=d.get("message", None))
 
 
-@dataclass
-class PermanentDeleteCluster:
-    cluster_id: str
-    """The cluster to be deleted."""
-
-    def as_dict(self) -> dict:
-        """Serializes the PermanentDeleteCluster into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the PermanentDeleteCluster into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> PermanentDeleteCluster:
-        """Deserializes the PermanentDeleteCluster from a dictionary."""
-        return cls(cluster_id=d.get("cluster_id", None))
-
-
 @dataclass
 class PermanentDeleteClusterResponse:
     def as_dict(self) -> dict:
@@ -8060,30 +6266,6 @@ class PermanentDeleteClusterResponse:
         return cls()
 
 
-@dataclass
-class PinCluster:
-    cluster_id: str
-
-    def as_dict(self) -> dict:
-        """Serializes the PinCluster into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the PinCluster into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> PinCluster:
-        """Deserializes the PinCluster from a dictionary."""
-        return cls(cluster_id=d.get("cluster_id", None))
-
-
 @dataclass
 class PinClusterResponse:
     def as_dict(self) -> dict:
@@ -8346,31 +6528,6 @@ class RCranLibrary:
         return cls(package=d.get("package", None), repo=d.get("repo", None))
 
 
-@dataclass
-class RemoveInstanceProfile:
-    instance_profile_arn: str
-    """The ARN of the instance profile to remove. This field is required."""
-
-    def as_dict(self) -> dict:
-        """Serializes the RemoveInstanceProfile into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.instance_profile_arn is not None:
-            body["instance_profile_arn"] = self.instance_profile_arn
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the RemoveInstanceProfile into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.instance_profile_arn is not None:
-            body["instance_profile_arn"] = self.instance_profile_arn
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> RemoveInstanceProfile:
-        """Deserializes the RemoveInstanceProfile from a dictionary."""
-        return cls(instance_profile_arn=d.get("instance_profile_arn", None))
-
-
 @dataclass
 class RemoveResponse:
     def as_dict(self) -> dict:
@@ -8389,57 +6546,6 @@ class RemoveResponse:
         return cls()
 
 
-@dataclass
-class ResizeCluster:
-    cluster_id: str
-    """The cluster to be resized."""
-
-    autoscale: Optional[AutoScale] = None
-    """Parameters needed in order to automatically scale clusters up and down based on load. Note:
-    autoscaling works best with DB runtime versions 3.0 or later."""
-
-    num_workers: Optional[int] = None
-    """Number of worker nodes that this cluster should have. A cluster has one Spark Driver and
-    `num_workers` Executors for a total of `num_workers` + 1 Spark nodes.
-    
-    Note: When reading the properties of a cluster, this field reflects the desired number of
-    workers rather than the actual current number of workers. For instance, if a cluster is resized
-    from 5 to 10 workers, this field will immediately be updated to reflect the target size of 10
-    workers, whereas the workers listed in `spark_info` will gradually increase from 5 to 10 as the
-    new nodes are provisioned."""
-
-    def as_dict(self) -> dict:
-        """Serializes the ResizeCluster into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.autoscale:
-            body["autoscale"] = self.autoscale.as_dict()
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        if self.num_workers is not None:
-            body["num_workers"] = self.num_workers
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the ResizeCluster into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.autoscale:
-            body["autoscale"] = self.autoscale
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        if self.num_workers is not None:
-            body["num_workers"] = self.num_workers
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> ResizeCluster:
-        """Deserializes the ResizeCluster from a dictionary."""
-        return cls(
-            autoscale=_from_dict(d, "autoscale", AutoScale),
-            cluster_id=d.get("cluster_id", None),
-            num_workers=d.get("num_workers", None),
-        )
-
-
 @dataclass
 class ResizeClusterResponse:
     def as_dict(self) -> dict:
@@ -8458,37 +6564,6 @@ class ResizeClusterResponse:
         return cls()
 
 
-@dataclass
-class RestartCluster:
-    cluster_id: str
-    """The cluster to be started."""
-
-    restart_user: Optional[str] = None
-
-    def as_dict(self) -> dict:
-        """Serializes the RestartCluster into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        if self.restart_user is not None:
-            body["restart_user"] = self.restart_user
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the RestartCluster into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        if self.restart_user is not None:
-            body["restart_user"] = self.restart_user
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> RestartCluster:
-        """Deserializes the RestartCluster from a dictionary."""
-        return cls(cluster_id=d.get("cluster_id", None), restart_user=d.get("restart_user", None))
-
-
 @dataclass
 class RestartClusterResponse:
     def as_dict(self) -> dict:
@@ -8850,31 +6925,6 @@ class SparkVersion:
         return cls(key=d.get("key", None), name=d.get("name", None))
 
 
-@dataclass
-class StartCluster:
-    cluster_id: str
-    """The cluster to be started."""
-
-    def as_dict(self) -> dict:
-        """Serializes the StartCluster into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the StartCluster into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> StartCluster:
-        """Deserializes the StartCluster from a dictionary."""
-        return cls(cluster_id=d.get("cluster_id", None))
-
-
 @dataclass
 class StartClusterResponse:
     def as_dict(self) -> dict:
@@ -9019,6 +7069,7 @@ class TerminationReasonCode(Enum):
     DOCKER_IMAGE_PULL_FAILURE = "DOCKER_IMAGE_PULL_FAILURE"
     DOCKER_IMAGE_TOO_LARGE_FOR_INSTANCE_EXCEPTION = "DOCKER_IMAGE_TOO_LARGE_FOR_INSTANCE_EXCEPTION"
     DOCKER_INVALID_OS_EXCEPTION = "DOCKER_INVALID_OS_EXCEPTION"
+    DRIVER_DNS_RESOLUTION_FAILURE = "DRIVER_DNS_RESOLUTION_FAILURE"
     DRIVER_EVICTION = "DRIVER_EVICTION"
     DRIVER_LAUNCH_TIMEOUT = "DRIVER_LAUNCH_TIMEOUT"
     DRIVER_NODE_UNREACHABLE = "DRIVER_NODE_UNREACHABLE"
@@ -9141,38 +7192,6 @@ class TerminationReasonType(Enum):
     SUCCESS = "SUCCESS"
 
 
-@dataclass
-class UninstallLibraries:
-    cluster_id: str
-    """Unique identifier for the cluster on which to uninstall these libraries."""
-
-    libraries: List[Library]
-    """The libraries to uninstall."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UninstallLibraries into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        if self.libraries:
-            body["libraries"] = [v.as_dict() for v in self.libraries]
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UninstallLibraries into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        if self.libraries:
-            body["libraries"] = self.libraries
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> UninstallLibraries:
-        """Deserializes the UninstallLibraries from a dictionary."""
-        return cls(cluster_id=d.get("cluster_id", None), libraries=_repeated_dict(d, "libraries", Library))
-
-
 @dataclass
 class UninstallLibrariesResponse:
     def as_dict(self) -> dict:
@@ -9191,30 +7210,6 @@ class UninstallLibrariesResponse:
         return cls()
 
 
-@dataclass
-class UnpinCluster:
-    cluster_id: str
-
-    def as_dict(self) -> dict:
-        """Serializes the UnpinCluster into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UnpinCluster into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> UnpinCluster:
-        """Deserializes the UnpinCluster from a dictionary."""
-        return cls(cluster_id=d.get("cluster_id", None))
-
-
 @dataclass
 class UnpinClusterResponse:
     def as_dict(self) -> dict:
@@ -9233,60 +7228,6 @@ class UnpinClusterResponse:
         return cls()
 
 
-@dataclass
-class UpdateCluster:
-    cluster_id: str
-    """ID of the cluster."""
-
-    update_mask: str
-    """Used to specify which cluster attributes and size fields to update. See
-    https://google.aip.dev/161 for more details.
-    
-    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."""
-
-    cluster: Optional[UpdateClusterResource] = None
-    """The cluster to be updated."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateCluster into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.cluster:
-            body["cluster"] = self.cluster.as_dict()
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_id
-        if self.update_mask is not None:
-            body["update_mask"] = self.update_mask
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateCluster into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.cluster:
-            body["cluster"] = self.cluster
-        if self.cluster_id is not None:
-            body["cluster_id"] = self.cluster_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]) -> UpdateCluster:
-        """Deserializes the UpdateCluster from a dictionary."""
-        return cls(
-            cluster=_from_dict(d, "cluster", UpdateClusterResource),
-            cluster_id=d.get("cluster_id", None),
-            update_mask=d.get("update_mask", None),
-        )
-
-
 @dataclass
 class UpdateClusterResource:
     autoscale: Optional[AutoScale] = None