databricks-sdk 0.37.0__py3-none-any.whl → 0.39.0__py3-none-any.whl

databricks/sdk/service/compute.py

@@ -55,6 +55,16 @@ class AddInstanceProfile:
         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."""
@@ -72,6 +82,11 @@ class AddResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AddResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AddResponse:
         """Deserializes the AddResponse from a dictionary."""
@@ -90,6 +105,12 @@ class Adlsgen2Info:
         if self.destination is not None: body['destination'] = self.destination
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Adlsgen2Info 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]) -> Adlsgen2Info:
         """Deserializes the Adlsgen2Info from a dictionary."""
@@ -113,6 +134,13 @@ class AutoScale:
         if self.min_workers is not None: body['min_workers'] = self.min_workers
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AutoScale into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.max_workers is not None: body['max_workers'] = self.max_workers
+        if self.min_workers is not None: body['min_workers'] = self.min_workers
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AutoScale:
         """Deserializes the AutoScale from a dictionary."""
@@ -216,6 +244,22 @@ class AwsAttributes:
         if self.zone_id is not None: body['zone_id'] = self.zone_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AwsAttributes into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.availability is not None: body['availability'] = self.availability
+        if self.ebs_volume_count is not None: body['ebs_volume_count'] = self.ebs_volume_count
+        if self.ebs_volume_iops is not None: body['ebs_volume_iops'] = self.ebs_volume_iops
+        if self.ebs_volume_size is not None: body['ebs_volume_size'] = self.ebs_volume_size
+        if self.ebs_volume_throughput is not None: body['ebs_volume_throughput'] = self.ebs_volume_throughput
+        if self.ebs_volume_type is not None: body['ebs_volume_type'] = self.ebs_volume_type
+        if self.first_on_demand is not None: body['first_on_demand'] = self.first_on_demand
+        if self.instance_profile_arn is not None: body['instance_profile_arn'] = self.instance_profile_arn
+        if self.spot_bid_price_percent is not None:
+            body['spot_bid_price_percent'] = self.spot_bid_price_percent
+        if self.zone_id is not None: body['zone_id'] = self.zone_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AwsAttributes:
         """Deserializes the AwsAttributes from a dictionary."""
@@ -275,6 +319,15 @@ class AzureAttributes:
         if self.spot_bid_max_price is not None: body['spot_bid_max_price'] = self.spot_bid_max_price
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AzureAttributes into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.availability is not None: body['availability'] = self.availability
+        if self.first_on_demand is not None: body['first_on_demand'] = self.first_on_demand
+        if self.log_analytics_info: body['log_analytics_info'] = self.log_analytics_info
+        if self.spot_bid_max_price is not None: body['spot_bid_max_price'] = self.spot_bid_max_price
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AzureAttributes:
         """Deserializes the AzureAttributes from a dictionary."""
@@ -310,6 +363,14 @@ class CancelCommand:
         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."""
@@ -326,6 +387,11 @@ class CancelResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CancelResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CancelResponse:
         """Deserializes the CancelResponse from a dictionary."""
@@ -347,6 +413,13 @@ class ChangeClusterOwner:
         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."""
@@ -361,6 +434,11 @@ class ChangeClusterOwnerResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ChangeClusterOwnerResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ChangeClusterOwnerResponse:
         """Deserializes the ChangeClusterOwnerResponse from a dictionary."""
@@ -382,6 +460,13 @@ class ClientsTypes:
         if self.notebooks is not None: body['notebooks'] = self.notebooks
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClientsTypes into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.jobs is not None: body['jobs'] = self.jobs
+        if self.notebooks is not None: body['notebooks'] = self.notebooks
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClientsTypes:
         """Deserializes the ClientsTypes from a dictionary."""
@@ -399,6 +484,12 @@ class CloneCluster:
         if self.source_cluster_id is not None: body['source_cluster_id'] = self.source_cluster_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CloneCluster into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.source_cluster_id is not None: body['source_cluster_id'] = self.source_cluster_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CloneCluster:
         """Deserializes the CloneCluster from a dictionary."""
@@ -415,6 +506,12 @@ class CloudProviderNodeInfo:
         if self.status: body['status'] = [v.value for v in self.status]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CloudProviderNodeInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.status: body['status'] = self.status
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CloudProviderNodeInfo:
         """Deserializes the CloudProviderNodeInfo from a dictionary."""
@@ -451,6 +548,16 @@ class ClusterAccessControlRequest:
         if self.user_name is not None: body['user_name'] = self.user_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterAccessControlRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.group_name is not None: body['group_name'] = self.group_name
+        if self.permission_level is not None: body['permission_level'] = self.permission_level
+        if self.service_principal_name is not None:
+            body['service_principal_name'] = self.service_principal_name
+        if self.user_name is not None: body['user_name'] = self.user_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterAccessControlRequest:
         """Deserializes the ClusterAccessControlRequest from a dictionary."""
@@ -488,6 +595,17 @@ class ClusterAccessControlResponse:
         if self.user_name is not None: body['user_name'] = self.user_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterAccessControlResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.all_permissions: body['all_permissions'] = self.all_permissions
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.group_name is not None: body['group_name'] = self.group_name
+        if self.service_principal_name is not None:
+            body['service_principal_name'] = self.service_principal_name
+        if self.user_name is not None: body['user_name'] = self.user_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterAccessControlResponse:
         """Deserializes the ClusterAccessControlResponse from a dictionary."""
@@ -666,6 +784,38 @@ class ClusterAttributes:
         if self.workload_type: body['workload_type'] = self.workload_type.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterAttributes into a shallow dictionary of its immediate attributes."""
+        body = {}
+        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_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.node_type_id is not None: body['node_type_id'] = self.node_type_id
+        if self.policy_id is not None: body['policy_id'] = self.policy_id
+        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.workload_type: body['workload_type'] = self.workload_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterAttributes:
         """Deserializes the ClusterAttributes from a dictionary."""
@@ -716,6 +866,14 @@ class ClusterCompliance:
         if self.violations: body['violations'] = self.violations
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterCompliance into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.cluster_id is not None: body['cluster_id'] = self.cluster_id
+        if self.is_compliant is not None: body['is_compliant'] = self.is_compliant
+        if self.violations: body['violations'] = self.violations
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterCompliance:
         """Deserializes the ClusterCompliance from a dictionary."""
@@ -1008,6 +1166,59 @@ class ClusterDetails:
         if self.workload_type: body['workload_type'] = self.workload_type.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterDetails into a shallow dictionary of its immediate attributes."""
+        body = {}
+        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_cores is not None: body['cluster_cores'] = self.cluster_cores
+        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_log_status: body['cluster_log_status'] = self.cluster_log_status
+        if self.cluster_memory_mb is not None: body['cluster_memory_mb'] = self.cluster_memory_mb
+        if self.cluster_name is not None: body['cluster_name'] = self.cluster_name
+        if self.cluster_source is not None: body['cluster_source'] = self.cluster_source
+        if self.creator_user_name is not None: body['creator_user_name'] = self.creator_user_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.default_tags: body['default_tags'] = self.default_tags
+        if self.docker_image: body['docker_image'] = self.docker_image
+        if self.driver: body['driver'] = self.driver
+        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.executors: body['executors'] = self.executors
+        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.jdbc_port is not None: body['jdbc_port'] = self.jdbc_port
+        if self.last_restarted_time is not None: body['last_restarted_time'] = self.last_restarted_time
+        if self.last_state_loss_time is not None: body['last_state_loss_time'] = self.last_state_loss_time
+        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.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_context_id is not None: body['spark_context_id'] = self.spark_context_id
+        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.spec: body['spec'] = self.spec
+        if self.ssh_public_keys: body['ssh_public_keys'] = self.ssh_public_keys
+        if self.start_time is not None: body['start_time'] = self.start_time
+        if self.state is not None: body['state'] = self.state
+        if self.state_message is not None: body['state_message'] = self.state_message
+        if self.terminated_time is not None: body['terminated_time'] = self.terminated_time
+        if self.termination_reason: body['termination_reason'] = self.termination_reason
+        if self.workload_type: body['workload_type'] = self.workload_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterDetails:
         """Deserializes the ClusterDetails from a dictionary."""
@@ -1086,6 +1297,16 @@ class ClusterEvent:
         if self.type is not None: body['type'] = self.type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterEvent into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.cluster_id is not None: body['cluster_id'] = self.cluster_id
+        if self.data_plane_event_details: body['data_plane_event_details'] = self.data_plane_event_details
+        if self.details: body['details'] = self.details
+        if self.timestamp is not None: body['timestamp'] = self.timestamp
+        if self.type is not None: body['type'] = self.type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterEvent:
         """Deserializes the ClusterEvent from a dictionary."""
@@ -1111,6 +1332,13 @@ class ClusterLibraryStatuses:
         if self.library_statuses: body['library_statuses'] = [v.as_dict() for v in self.library_statuses]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterLibraryStatuses into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.cluster_id is not None: body['cluster_id'] = self.cluster_id
+        if self.library_statuses: body['library_statuses'] = self.library_statuses
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterLibraryStatuses:
         """Deserializes the ClusterLibraryStatuses from a dictionary."""
@@ -1137,6 +1365,13 @@ class ClusterLogConf:
         if self.s3: body['s3'] = self.s3.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterLogConf into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.dbfs: body['dbfs'] = self.dbfs
+        if self.s3: body['s3'] = self.s3
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterLogConf:
         """Deserializes the ClusterLogConf from a dictionary."""
@@ -1160,6 +1395,14 @@ class ClusterPermission:
         if self.permission_level is not None: body['permission_level'] = self.permission_level.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterPermission into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.inherited is not None: body['inherited'] = self.inherited
+        if self.inherited_from_object: body['inherited_from_object'] = self.inherited_from_object
+        if self.permission_level is not None: body['permission_level'] = self.permission_level
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterPermission:
         """Deserializes the ClusterPermission from a dictionary."""
@@ -1193,6 +1436,14 @@ class ClusterPermissions:
         if self.object_type is not None: body['object_type'] = self.object_type
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterPermissions into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.access_control_list: body['access_control_list'] = self.access_control_list
+        if self.object_id is not None: body['object_id'] = self.object_id
+        if self.object_type is not None: body['object_type'] = self.object_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterPermissions:
         """Deserializes the ClusterPermissions from a dictionary."""
@@ -1215,6 +1466,13 @@ class ClusterPermissionsDescription:
         if self.permission_level is not None: body['permission_level'] = self.permission_level.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterPermissionsDescription into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.description is not None: body['description'] = self.description
+        if self.permission_level is not None: body['permission_level'] = self.permission_level
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterPermissionsDescription:
         """Deserializes the ClusterPermissionsDescription from a dictionary."""
@@ -1237,6 +1495,13 @@ class ClusterPermissionsRequest:
         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."""
@@ -1268,6 +1533,16 @@ class ClusterPolicyAccessControlRequest:
         if self.user_name is not None: body['user_name'] = self.user_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterPolicyAccessControlRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.group_name is not None: body['group_name'] = self.group_name
+        if self.permission_level is not None: body['permission_level'] = self.permission_level
+        if self.service_principal_name is not None:
+            body['service_principal_name'] = self.service_principal_name
+        if self.user_name is not None: body['user_name'] = self.user_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterPolicyAccessControlRequest:
         """Deserializes the ClusterPolicyAccessControlRequest from a dictionary."""
@@ -1305,6 +1580,17 @@ class ClusterPolicyAccessControlResponse:
         if self.user_name is not None: body['user_name'] = self.user_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterPolicyAccessControlResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.all_permissions: body['all_permissions'] = self.all_permissions
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.group_name is not None: body['group_name'] = self.group_name
+        if self.service_principal_name is not None:
+            body['service_principal_name'] = self.service_principal_name
+        if self.user_name is not None: body['user_name'] = self.user_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterPolicyAccessControlResponse:
         """Deserializes the ClusterPolicyAccessControlResponse from a dictionary."""
@@ -1332,6 +1618,14 @@ class ClusterPolicyPermission:
         if self.permission_level is not None: body['permission_level'] = self.permission_level.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterPolicyPermission into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.inherited is not None: body['inherited'] = self.inherited
+        if self.inherited_from_object: body['inherited_from_object'] = self.inherited_from_object
+        if self.permission_level is not None: body['permission_level'] = self.permission_level
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterPolicyPermission:
         """Deserializes the ClusterPolicyPermission from a dictionary."""
@@ -1363,6 +1657,14 @@ class ClusterPolicyPermissions:
         if self.object_type is not None: body['object_type'] = self.object_type
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterPolicyPermissions into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.access_control_list: body['access_control_list'] = self.access_control_list
+        if self.object_id is not None: body['object_id'] = self.object_id
+        if self.object_type is not None: body['object_type'] = self.object_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterPolicyPermissions:
         """Deserializes the ClusterPolicyPermissions from a dictionary."""
@@ -1386,6 +1688,13 @@ class ClusterPolicyPermissionsDescription:
         if self.permission_level is not None: body['permission_level'] = self.permission_level.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterPolicyPermissionsDescription into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.description is not None: body['description'] = self.description
+        if self.permission_level is not None: body['permission_level'] = self.permission_level
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterPolicyPermissionsDescription:
         """Deserializes the ClusterPolicyPermissionsDescription from a dictionary."""
@@ -1408,6 +1717,13 @@ class ClusterPolicyPermissionsRequest:
         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."""
@@ -1442,6 +1758,14 @@ class ClusterSettingsChange:
         if self.previous_value is not None: body['previous_value'] = self.previous_value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterSettingsChange into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.field is not None: body['field'] = self.field
+        if self.new_value is not None: body['new_value'] = self.new_value
+        if self.previous_value is not None: body['previous_value'] = self.previous_value
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterSettingsChange:
         """Deserializes the ClusterSettingsChange from a dictionary."""
@@ -1473,6 +1797,13 @@ class ClusterSize:
         if self.num_workers is not None: body['num_workers'] = self.num_workers
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterSize into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.autoscale: body['autoscale'] = self.autoscale
+        if self.num_workers is not None: body['num_workers'] = self.num_workers
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterSize:
         """Deserializes the ClusterSize from a dictionary."""
@@ -1682,6 +2013,42 @@ class ClusterSpec:
         if self.workload_type: body['workload_type'] = self.workload_type.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterSpec 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_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.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.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.workload_type: body['workload_type'] = self.workload_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterSpec:
         """Deserializes the ClusterSpec from a dictionary."""
@@ -1736,6 +2103,15 @@ class Command:
         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."""
@@ -1771,6 +2147,14 @@ class CommandStatusResponse:
         if self.status is not None: body['status'] = self.status.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CommandStatusResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.id is not None: body['id'] = self.id
+        if self.results: body['results'] = self.results
+        if self.status is not None: body['status'] = self.status
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CommandStatusResponse:
         """Deserializes the CommandStatusResponse from a dictionary."""
@@ -1799,6 +2183,13 @@ class ContextStatusResponse:
         if self.status is not None: body['status'] = self.status.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ContextStatusResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.id is not None: body['id'] = self.id
+        if self.status is not None: body['status'] = self.status
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ContextStatusResponse:
         """Deserializes the ContextStatusResponse from a dictionary."""
@@ -2000,14 +2391,51 @@ class CreateCluster:
         if self.workload_type: body['workload_type'] = self.workload_type.as_dict()
         return body
 
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CreateCluster:
-        """Deserializes the CreateCluster 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),
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateCluster 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.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.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.workload_type: body['workload_type'] = self.workload_type
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> CreateCluster:
+        """Deserializes the CreateCluster 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),
@@ -2043,6 +2471,12 @@ class CreateClusterResponse:
         if self.cluster_id is not None: body['cluster_id'] = self.cluster_id
         return body
 
+    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
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateClusterResponse:
         """Deserializes the CreateClusterResponse from a dictionary."""
@@ -2063,6 +2497,13 @@ class CreateContext:
         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."""
+        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."""
@@ -2152,6 +2593,25 @@ class CreateInstancePool:
             body['preloaded_spark_versions'] = [v for v in self.preloaded_spark_versions]
         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
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateInstancePool:
         """Deserializes the CreateInstancePool from a dictionary."""
@@ -2181,6 +2641,12 @@ class CreateInstancePoolResponse:
         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."""
+        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."""
@@ -2238,6 +2704,19 @@ class CreatePolicy:
         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."""
@@ -2261,6 +2740,12 @@ class CreatePolicyResponse:
         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."""
@@ -2278,6 +2763,12 @@ class CreateResponse:
         if self.script_id is not None: body['script_id'] = self.script_id
         return body
 
+    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
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateResponse:
         """Deserializes the CreateResponse from a dictionary."""
@@ -2294,6 +2785,12 @@ class Created:
         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."""
@@ -2323,6 +2820,15 @@ class DataPlaneEventDetails:
         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."""
@@ -2379,6 +2885,12 @@ class DbfsStorageInfo:
         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."""
@@ -2396,6 +2908,12 @@ class DeleteCluster:
         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."""
@@ -2410,6 +2928,11 @@ class DeleteClusterResponse:
         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."""
@@ -2427,6 +2950,12 @@ class DeleteInstancePool:
         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."""
@@ -2441,6 +2970,11 @@ class DeleteInstancePoolResponse:
         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."""
@@ -2458,6 +2992,12 @@ class DeletePolicy:
         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."""
@@ -2472,6 +3012,11 @@ class DeletePolicyResponse:
         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."""
@@ -2486,6 +3031,11 @@ class DeleteResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeleteResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DeleteResponse:
         """Deserializes the DeleteResponse from a dictionary."""
@@ -2505,6 +3055,13 @@ class DestroyContext:
         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."""
@@ -2519,6 +3076,11 @@ class DestroyResponse:
         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."""
@@ -2567,6 +3129,16 @@ class DiskSpec:
         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."""
@@ -2591,6 +3163,14 @@ class DiskType:
         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."""
@@ -2625,6 +3205,13 @@ class DockerBasicAuth:
         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."""
@@ -2645,6 +3232,13 @@ class DockerImage:
         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."""
@@ -2852,6 +3446,43 @@ class EditCluster:
         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.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.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.workload_type: body['workload_type'] = self.workload_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EditCluster:
         """Deserializes the EditCluster from a dictionary."""
@@ -2893,6 +3524,11 @@ class EditClusterResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EditClusterResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EditClusterResponse:
         """Deserializes the EditClusterResponse from a dictionary."""
@@ -2948,6 +3584,19 @@ class EditInstancePool:
         if self.node_type_id is not None: body['node_type_id'] = self.node_type_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EditInstancePool 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
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EditInstancePool:
         """Deserializes the EditInstancePool from a dictionary."""
@@ -2968,6 +3617,11 @@ class EditInstancePoolResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EditInstancePoolResponse 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."""
@@ -3029,6 +3683,20 @@ class EditPolicy:
         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."""
+        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."""
@@ -3050,6 +3718,11 @@ class EditPolicyResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EditPolicyResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EditPolicyResponse:
         """Deserializes the EditPolicyResponse from a dictionary."""
@@ -3064,6 +3737,11 @@ class EditResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EditResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EditResponse:
         """Deserializes the EditResponse from a dictionary."""
@@ -3086,6 +3764,13 @@ class EnforceClusterComplianceRequest:
         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."""
@@ -3109,6 +3794,13 @@ class EnforceClusterComplianceResponse:
         if self.has_changes is not None: body['has_changes'] = self.has_changes
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EnforceClusterComplianceResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.changes: body['changes'] = self.changes
+        if self.has_changes is not None: body['has_changes'] = self.has_changes
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EnforceClusterComplianceResponse:
         """Deserializes the EnforceClusterComplianceResponse from a dictionary."""
@@ -3141,6 +3833,13 @@ class Environment:
         if self.dependencies: body['dependencies'] = [v for v in self.dependencies]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Environment into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.client is not None: body['client'] = self.client
+        if self.dependencies: body['dependencies'] = self.dependencies
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> Environment:
         """Deserializes the Environment from a dictionary."""
@@ -3238,6 +3937,32 @@ class EventDetails:
         if self.user is not None: body['user'] = self.user
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EventDetails into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.attributes: body['attributes'] = self.attributes
+        if self.cause is not None: body['cause'] = self.cause
+        if self.cluster_size: body['cluster_size'] = self.cluster_size
+        if self.current_num_vcpus is not None: body['current_num_vcpus'] = self.current_num_vcpus
+        if self.current_num_workers is not None: body['current_num_workers'] = self.current_num_workers
+        if self.did_not_expand_reason is not None: body['did_not_expand_reason'] = self.did_not_expand_reason
+        if self.disk_size is not None: body['disk_size'] = self.disk_size
+        if self.driver_state_message is not None: body['driver_state_message'] = self.driver_state_message
+        if self.enable_termination_for_node_blocklisted is not None:
+            body['enable_termination_for_node_blocklisted'] = self.enable_termination_for_node_blocklisted
+        if self.free_space is not None: body['free_space'] = self.free_space
+        if self.init_scripts: body['init_scripts'] = self.init_scripts
+        if self.instance_id is not None: body['instance_id'] = self.instance_id
+        if self.job_run_name is not None: body['job_run_name'] = self.job_run_name
+        if self.previous_attributes: body['previous_attributes'] = self.previous_attributes
+        if self.previous_cluster_size: body['previous_cluster_size'] = self.previous_cluster_size
+        if self.previous_disk_size is not None: body['previous_disk_size'] = self.previous_disk_size
+        if self.reason: body['reason'] = self.reason
+        if self.target_num_vcpus is not None: body['target_num_vcpus'] = self.target_num_vcpus
+        if self.target_num_workers is not None: body['target_num_workers'] = self.target_num_workers
+        if self.user is not None: body['user'] = self.user
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EventDetails:
         """Deserializes the EventDetails from a dictionary."""
@@ -3348,6 +4073,19 @@ class GcpAttributes:
         if self.zone_id is not None: body['zone_id'] = self.zone_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GcpAttributes into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.availability is not None: body['availability'] = self.availability
+        if self.boot_disk_size is not None: body['boot_disk_size'] = self.boot_disk_size
+        if self.google_service_account is not None:
+            body['google_service_account'] = self.google_service_account
+        if self.local_ssd_count is not None: body['local_ssd_count'] = self.local_ssd_count
+        if self.use_preemptible_executors is not None:
+            body['use_preemptible_executors'] = self.use_preemptible_executors
+        if self.zone_id is not None: body['zone_id'] = self.zone_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GcpAttributes:
         """Deserializes the GcpAttributes from a dictionary."""
@@ -3379,6 +4117,12 @@ class GcsStorageInfo:
         if self.destination is not None: body['destination'] = self.destination
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GcsStorageInfo 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]) -> GcsStorageInfo:
         """Deserializes the GcsStorageInfo from a dictionary."""
@@ -3403,6 +4147,13 @@ class GetClusterComplianceResponse:
         if self.violations: body['violations'] = self.violations
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GetClusterComplianceResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.is_compliant is not None: body['is_compliant'] = self.is_compliant
+        if self.violations: body['violations'] = self.violations
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GetClusterComplianceResponse:
         """Deserializes the GetClusterComplianceResponse from a dictionary."""
@@ -3420,6 +4171,12 @@ class GetClusterPermissionLevelsResponse:
         if self.permission_levels: body['permission_levels'] = [v.as_dict() for v in self.permission_levels]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GetClusterPermissionLevelsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.permission_levels: body['permission_levels'] = self.permission_levels
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GetClusterPermissionLevelsResponse:
         """Deserializes the GetClusterPermissionLevelsResponse from a dictionary."""
@@ -3437,6 +4194,12 @@ class GetClusterPolicyPermissionLevelsResponse:
         if self.permission_levels: body['permission_levels'] = [v.as_dict() for v in self.permission_levels]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GetClusterPolicyPermissionLevelsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.permission_levels: body['permission_levels'] = self.permission_levels
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GetClusterPolicyPermissionLevelsResponse:
         """Deserializes the GetClusterPolicyPermissionLevelsResponse from a dictionary."""
@@ -3482,6 +4245,18 @@ class GetEvents:
         if self.start_time is not None: body['start_time'] = self.start_time
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GetEvents into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.cluster_id is not None: body['cluster_id'] = self.cluster_id
+        if self.end_time is not None: body['end_time'] = self.end_time
+        if self.event_types: body['event_types'] = self.event_types
+        if self.limit is not None: body['limit'] = self.limit
+        if self.offset is not None: body['offset'] = self.offset
+        if self.order is not None: body['order'] = self.order
+        if self.start_time is not None: body['start_time'] = self.start_time
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GetEvents:
         """Deserializes the GetEvents from a dictionary."""
@@ -3521,6 +4296,14 @@ class GetEventsResponse:
         if self.total_count is not None: body['total_count'] = self.total_count
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GetEventsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.events: body['events'] = self.events
+        if self.next_page: body['next_page'] = self.next_page
+        if self.total_count is not None: body['total_count'] = self.total_count
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GetEventsResponse:
         """Deserializes the GetEventsResponse from a dictionary."""
@@ -3640,6 +4423,30 @@ class GetInstancePool:
         if self.status: body['status'] = self.status.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GetInstancePool 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.default_tags: body['default_tags'] = self.default_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_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.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.state is not None: body['state'] = self.state
+        if self.stats: body['stats'] = self.stats
+        if self.status: body['status'] = self.status
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GetInstancePool:
         """Deserializes the GetInstancePool from a dictionary."""
@@ -3674,6 +4481,12 @@ class GetInstancePoolPermissionLevelsResponse:
         if self.permission_levels: body['permission_levels'] = [v.as_dict() for v in self.permission_levels]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GetInstancePoolPermissionLevelsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.permission_levels: body['permission_levels'] = self.permission_levels
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GetInstancePoolPermissionLevelsResponse:
         """Deserializes the GetInstancePoolPermissionLevelsResponse from a dictionary."""
@@ -3692,6 +4505,12 @@ class GetSparkVersionsResponse:
         if self.versions: body['versions'] = [v.as_dict() for v in self.versions]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GetSparkVersionsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.versions: body['versions'] = self.versions
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GetSparkVersionsResponse:
         """Deserializes the GetSparkVersionsResponse from a dictionary."""
@@ -3729,6 +4548,15 @@ class GlobalInitScriptCreateRequest:
         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."""
@@ -3778,6 +4606,19 @@ class GlobalInitScriptDetails:
         if self.updated_by is not None: body['updated_by'] = self.updated_by
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GlobalInitScriptDetails into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.created_by is not None: body['created_by'] = self.created_by
+        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_id is not None: body['script_id'] = self.script_id
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.updated_by is not None: body['updated_by'] = self.updated_by
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GlobalInitScriptDetails:
         """Deserializes the GlobalInitScriptDetails from a dictionary."""
@@ -3835,6 +4676,20 @@ class GlobalInitScriptDetailsWithContent:
         if self.updated_by is not None: body['updated_by'] = self.updated_by
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GlobalInitScriptDetailsWithContent into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.created_by is not None: body['created_by'] = self.created_by
+        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
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.updated_by is not None: body['updated_by'] = self.updated_by
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GlobalInitScriptDetailsWithContent:
         """Deserializes the GlobalInitScriptDetailsWithContent from a dictionary."""
@@ -3884,6 +4739,16 @@ class GlobalInitScriptUpdateRequest:
         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."""
@@ -3913,6 +4778,14 @@ class InitScriptEventDetails:
         if self.reported_for_node is not None: body['reported_for_node'] = self.reported_for_node
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the InitScriptEventDetails into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.cluster: body['cluster'] = self.cluster
+        if self.global_: body['global'] = self.global_
+        if self.reported_for_node is not None: body['reported_for_node'] = self.reported_for_node
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> InitScriptEventDetails:
         """Deserializes the InitScriptEventDetails from a dictionary."""
@@ -3941,6 +4814,15 @@ class InitScriptExecutionDetails:
         if self.status is not None: body['status'] = self.status.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the InitScriptExecutionDetails into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.error_message is not None: body['error_message'] = self.error_message
+        if self.execution_duration_seconds is not None:
+            body['execution_duration_seconds'] = self.execution_duration_seconds
+        if self.status is not None: body['status'] = self.status
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> InitScriptExecutionDetails:
         """Deserializes the InitScriptExecutionDetails from a dictionary."""
@@ -4003,6 +4885,18 @@ class InitScriptInfo:
         if self.workspace: body['workspace'] = self.workspace.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the InitScriptInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.abfss: body['abfss'] = self.abfss
+        if self.dbfs: body['dbfs'] = self.dbfs
+        if self.file: body['file'] = self.file
+        if self.gcs: body['gcs'] = self.gcs
+        if self.s3: body['s3'] = self.s3
+        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]) -> InitScriptInfo:
         """Deserializes the InitScriptInfo from a dictionary."""
@@ -4030,6 +4924,13 @@ class InitScriptInfoAndExecutionDetails:
         if self.script: body['script'] = self.script.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the InitScriptInfoAndExecutionDetails into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.execution_details: body['execution_details'] = self.execution_details
+        if self.script: body['script'] = self.script
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> InitScriptInfoAndExecutionDetails:
         """Deserializes the InitScriptInfoAndExecutionDetails from a dictionary."""
@@ -4052,6 +4953,13 @@ class InstallLibraries:
         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
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> InstallLibraries:
         """Deserializes the InstallLibraries from a dictionary."""
@@ -4066,6 +4974,11 @@ class InstallLibrariesResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the InstallLibrariesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> InstallLibrariesResponse:
         """Deserializes the InstallLibrariesResponse from a dictionary."""
@@ -4096,6 +5009,16 @@ class InstancePoolAccessControlRequest:
         if self.user_name is not None: body['user_name'] = self.user_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the InstancePoolAccessControlRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.group_name is not None: body['group_name'] = self.group_name
+        if self.permission_level is not None: body['permission_level'] = self.permission_level
+        if self.service_principal_name is not None:
+            body['service_principal_name'] = self.service_principal_name
+        if self.user_name is not None: body['user_name'] = self.user_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> InstancePoolAccessControlRequest:
         """Deserializes the InstancePoolAccessControlRequest from a dictionary."""
@@ -4133,6 +5056,17 @@ class InstancePoolAccessControlResponse:
         if self.user_name is not None: body['user_name'] = self.user_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the InstancePoolAccessControlResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.all_permissions: body['all_permissions'] = self.all_permissions
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.group_name is not None: body['group_name'] = self.group_name
+        if self.service_principal_name is not None:
+            body['service_principal_name'] = self.service_principal_name
+        if self.user_name is not None: body['user_name'] = self.user_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> InstancePoolAccessControlResponse:
         """Deserializes the InstancePoolAccessControlResponse from a dictionary."""
@@ -4254,6 +5188,30 @@ class InstancePoolAndStats:
         if self.status: body['status'] = self.status.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the InstancePoolAndStats 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.default_tags: body['default_tags'] = self.default_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_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.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.state is not None: body['state'] = self.state
+        if self.stats: body['stats'] = self.stats
+        if self.status: body['status'] = self.status
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> InstancePoolAndStats:
         """Deserializes the InstancePoolAndStats from a dictionary."""
@@ -4313,6 +5271,15 @@ class InstancePoolAwsAttributes:
         if self.zone_id is not None: body['zone_id'] = self.zone_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the InstancePoolAwsAttributes into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.availability is not None: body['availability'] = self.availability
+        if self.spot_bid_price_percent is not None:
+            body['spot_bid_price_percent'] = self.spot_bid_price_percent
+        if self.zone_id is not None: body['zone_id'] = self.zone_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> InstancePoolAwsAttributes:
         """Deserializes the InstancePoolAwsAttributes from a dictionary."""
@@ -4348,6 +5315,13 @@ class InstancePoolAzureAttributes:
         if self.spot_bid_max_price is not None: body['spot_bid_max_price'] = self.spot_bid_max_price
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the InstancePoolAzureAttributes into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.availability is not None: body['availability'] = self.availability
+        if self.spot_bid_max_price is not None: body['spot_bid_max_price'] = self.spot_bid_max_price
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> InstancePoolAzureAttributes:
         """Deserializes the InstancePoolAzureAttributes from a dictionary."""
@@ -4399,6 +5373,14 @@ class InstancePoolGcpAttributes:
         if self.zone_id is not None: body['zone_id'] = self.zone_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the InstancePoolGcpAttributes into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.gcp_availability is not None: body['gcp_availability'] = self.gcp_availability
+        if self.local_ssd_count is not None: body['local_ssd_count'] = self.local_ssd_count
+        if self.zone_id is not None: body['zone_id'] = self.zone_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> InstancePoolGcpAttributes:
         """Deserializes the InstancePoolGcpAttributes from a dictionary."""
@@ -4424,6 +5406,14 @@ class InstancePoolPermission:
         if self.permission_level is not None: body['permission_level'] = self.permission_level.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the InstancePoolPermission into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.inherited is not None: body['inherited'] = self.inherited
+        if self.inherited_from_object: body['inherited_from_object'] = self.inherited_from_object
+        if self.permission_level is not None: body['permission_level'] = self.permission_level
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> InstancePoolPermission:
         """Deserializes the InstancePoolPermission from a dictionary."""
@@ -4456,6 +5446,14 @@ class InstancePoolPermissions:
         if self.object_type is not None: body['object_type'] = self.object_type
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the InstancePoolPermissions into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.access_control_list: body['access_control_list'] = self.access_control_list
+        if self.object_id is not None: body['object_id'] = self.object_id
+        if self.object_type is not None: body['object_type'] = self.object_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> InstancePoolPermissions:
         """Deserializes the InstancePoolPermissions from a dictionary."""
@@ -4479,6 +5477,13 @@ class InstancePoolPermissionsDescription:
         if self.permission_level is not None: body['permission_level'] = self.permission_level.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the InstancePoolPermissionsDescription into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.description is not None: body['description'] = self.description
+        if self.permission_level is not None: body['permission_level'] = self.permission_level
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> InstancePoolPermissionsDescription:
         """Deserializes the InstancePoolPermissionsDescription from a dictionary."""
@@ -4501,6 +5506,13 @@ class InstancePoolPermissionsRequest:
         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."""
@@ -4540,6 +5552,15 @@ class InstancePoolStats:
         if self.used_count is not None: body['used_count'] = self.used_count
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the InstancePoolStats into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.idle_count is not None: body['idle_count'] = self.idle_count
+        if self.pending_idle_count is not None: body['pending_idle_count'] = self.pending_idle_count
+        if self.pending_used_count is not None: body['pending_used_count'] = self.pending_used_count
+        if self.used_count is not None: body['used_count'] = self.used_count
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> InstancePoolStats:
         """Deserializes the InstancePoolStats from a dictionary."""
@@ -4563,6 +5584,12 @@ class InstancePoolStatus:
             body['pending_instance_errors'] = [v.as_dict() for v in self.pending_instance_errors]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the InstancePoolStatus into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.pending_instance_errors: body['pending_instance_errors'] = self.pending_instance_errors
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> InstancePoolStatus:
         """Deserializes the InstancePoolStatus from a dictionary."""
@@ -4598,6 +5625,15 @@ class InstanceProfile:
             body['is_meta_instance_profile'] = self.is_meta_instance_profile
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the InstanceProfile 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
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> InstanceProfile:
         """Deserializes the InstanceProfile from a dictionary."""
@@ -4660,6 +5696,18 @@ class Library:
         if self.whl is not None: body['whl'] = self.whl
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Library into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.cran: body['cran'] = self.cran
+        if self.egg is not None: body['egg'] = self.egg
+        if self.jar is not None: body['jar'] = self.jar
+        if self.maven: body['maven'] = self.maven
+        if self.pypi: body['pypi'] = self.pypi
+        if self.requirements is not None: body['requirements'] = self.requirements
+        if self.whl is not None: body['whl'] = self.whl
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> Library:
         """Deserializes the Library from a dictionary."""
@@ -4698,6 +5746,16 @@ class LibraryFullStatus:
         if self.status is not None: body['status'] = self.status.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the LibraryFullStatus into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.is_library_for_all_clusters is not None:
+            body['is_library_for_all_clusters'] = self.is_library_for_all_clusters
+        if self.library: body['library'] = self.library
+        if self.messages: body['messages'] = self.messages
+        if self.status is not None: body['status'] = self.status
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> LibraryFullStatus:
         """Deserializes the LibraryFullStatus from a dictionary."""
@@ -4731,6 +5789,12 @@ class ListAllClusterLibraryStatusesResponse:
         if self.statuses: body['statuses'] = [v.as_dict() for v in self.statuses]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListAllClusterLibraryStatusesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.statuses: body['statuses'] = self.statuses
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListAllClusterLibraryStatusesResponse:
         """Deserializes the ListAllClusterLibraryStatusesResponse from a dictionary."""
@@ -4752,6 +5816,13 @@ class ListAvailableZonesResponse:
         if self.zones: body['zones'] = [v for v in self.zones]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListAvailableZonesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.default_zone is not None: body['default_zone'] = self.default_zone
+        if self.zones: body['zones'] = self.zones
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListAvailableZonesResponse:
         """Deserializes the ListAvailableZonesResponse from a dictionary."""
@@ -4779,6 +5850,14 @@ class ListClusterCompliancesResponse:
         if self.prev_page_token is not None: body['prev_page_token'] = self.prev_page_token
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListClusterCompliancesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.clusters: body['clusters'] = self.clusters
+        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.prev_page_token is not None: body['prev_page_token'] = self.prev_page_token
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListClusterCompliancesResponse:
         """Deserializes the ListClusterCompliancesResponse from a dictionary."""
@@ -4810,6 +5889,15 @@ class ListClustersFilterBy:
         if self.policy_id is not None: body['policy_id'] = self.policy_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListClustersFilterBy into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.cluster_sources: body['cluster_sources'] = self.cluster_sources
+        if self.cluster_states: body['cluster_states'] = self.cluster_states
+        if self.is_pinned is not None: body['is_pinned'] = self.is_pinned
+        if self.policy_id is not None: body['policy_id'] = self.policy_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListClustersFilterBy:
         """Deserializes the ListClustersFilterBy from a dictionary."""
@@ -4840,6 +5928,14 @@ class ListClustersResponse:
         if self.prev_page_token is not None: body['prev_page_token'] = self.prev_page_token
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListClustersResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.clusters: body['clusters'] = self.clusters
+        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.prev_page_token is not None: body['prev_page_token'] = self.prev_page_token
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListClustersResponse:
         """Deserializes the ListClustersResponse from a dictionary."""
@@ -4864,6 +5960,13 @@ class ListClustersSortBy:
         if self.field is not None: body['field'] = self.field.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListClustersSortBy into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.direction is not None: body['direction'] = self.direction
+        if self.field is not None: body['field'] = self.field
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListClustersSortBy:
         """Deserializes the ListClustersSortBy from a dictionary."""
@@ -4896,6 +5999,12 @@ class ListGlobalInitScriptsResponse:
         if self.scripts: body['scripts'] = [v.as_dict() for v in self.scripts]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListGlobalInitScriptsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.scripts: body['scripts'] = self.scripts
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListGlobalInitScriptsResponse:
         """Deserializes the ListGlobalInitScriptsResponse from a dictionary."""
@@ -4912,6 +6021,12 @@ class ListInstancePools:
         if self.instance_pools: body['instance_pools'] = [v.as_dict() for v in self.instance_pools]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListInstancePools into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.instance_pools: body['instance_pools'] = self.instance_pools
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListInstancePools:
         """Deserializes the ListInstancePools from a dictionary."""
@@ -4929,6 +6044,12 @@ class ListInstanceProfilesResponse:
         if self.instance_profiles: body['instance_profiles'] = [v.as_dict() for v in self.instance_profiles]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListInstanceProfilesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.instance_profiles: body['instance_profiles'] = self.instance_profiles
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListInstanceProfilesResponse:
         """Deserializes the ListInstanceProfilesResponse from a dictionary."""
@@ -4946,6 +6067,12 @@ class ListNodeTypesResponse:
         if self.node_types: body['node_types'] = [v.as_dict() for v in self.node_types]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListNodeTypesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.node_types: body['node_types'] = self.node_types
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListNodeTypesResponse:
         """Deserializes the ListNodeTypesResponse from a dictionary."""
@@ -4963,6 +6090,12 @@ class ListPoliciesResponse:
         if self.policies: body['policies'] = [v.as_dict() for v in self.policies]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListPoliciesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.policies: body['policies'] = self.policies
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListPoliciesResponse:
         """Deserializes the ListPoliciesResponse from a dictionary."""
@@ -4985,6 +6118,13 @@ class ListPolicyFamiliesResponse:
         if self.policy_families: body['policy_families'] = [v.as_dict() for v in self.policy_families]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListPolicyFamiliesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.policy_families: body['policy_families'] = self.policy_families
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListPolicyFamiliesResponse:
         """Deserializes the ListPolicyFamiliesResponse from a dictionary."""
@@ -5016,6 +6156,12 @@ class LocalFileInfo:
         if self.destination is not None: body['destination'] = self.destination
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the LocalFileInfo 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]) -> LocalFileInfo:
         """Deserializes the LocalFileInfo from a dictionary."""
@@ -5039,6 +6185,15 @@ class LogAnalyticsInfo:
             body['log_analytics_workspace_id'] = self.log_analytics_workspace_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the LogAnalyticsInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.log_analytics_primary_key is not None:
+            body['log_analytics_primary_key'] = self.log_analytics_primary_key
+        if self.log_analytics_workspace_id is not None:
+            body['log_analytics_workspace_id'] = self.log_analytics_workspace_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> LogAnalyticsInfo:
         """Deserializes the LogAnalyticsInfo from a dictionary."""
@@ -5063,6 +6218,13 @@ class LogSyncStatus:
         if self.last_exception is not None: body['last_exception'] = self.last_exception
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the LogSyncStatus into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.last_attempted is not None: body['last_attempted'] = self.last_attempted
+        if self.last_exception is not None: body['last_exception'] = self.last_exception
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> LogSyncStatus:
         """Deserializes the LogSyncStatus from a dictionary."""
@@ -5092,6 +6254,14 @@ class MavenLibrary:
         if self.repo is not None: body['repo'] = self.repo
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the MavenLibrary into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.coordinates is not None: body['coordinates'] = self.coordinates
+        if self.exclusions: body['exclusions'] = self.exclusions
+        if self.repo is not None: body['repo'] = self.repo
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> MavenLibrary:
         """Deserializes the MavenLibrary from a dictionary."""
@@ -5123,6 +6293,17 @@ class NodeInstanceType:
         if self.local_nvme_disks is not None: body['local_nvme_disks'] = self.local_nvme_disks
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the NodeInstanceType into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.instance_type_id is not None: body['instance_type_id'] = self.instance_type_id
+        if self.local_disk_size_gb is not None: body['local_disk_size_gb'] = self.local_disk_size_gb
+        if self.local_disks is not None: body['local_disks'] = self.local_disks
+        if self.local_nvme_disk_size_gb is not None:
+            body['local_nvme_disk_size_gb'] = self.local_nvme_disk_size_gb
+        if self.local_nvme_disks is not None: body['local_nvme_disks'] = self.local_nvme_disks
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> NodeInstanceType:
         """Deserializes the NodeInstanceType from a dictionary."""
@@ -5217,6 +6398,34 @@ class NodeType:
         if self.supports_elastic_disk is not None: body['supports_elastic_disk'] = self.supports_elastic_disk
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the NodeType into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.category is not None: body['category'] = self.category
+        if self.description is not None: body['description'] = self.description
+        if self.display_order is not None: body['display_order'] = self.display_order
+        if self.instance_type_id is not None: body['instance_type_id'] = self.instance_type_id
+        if self.is_deprecated is not None: body['is_deprecated'] = self.is_deprecated
+        if self.is_encrypted_in_transit is not None:
+            body['is_encrypted_in_transit'] = self.is_encrypted_in_transit
+        if self.is_graviton is not None: body['is_graviton'] = self.is_graviton
+        if self.is_hidden is not None: body['is_hidden'] = self.is_hidden
+        if self.is_io_cache_enabled is not None: body['is_io_cache_enabled'] = self.is_io_cache_enabled
+        if self.memory_mb is not None: body['memory_mb'] = self.memory_mb
+        if self.node_info: body['node_info'] = self.node_info
+        if self.node_instance_type: body['node_instance_type'] = self.node_instance_type
+        if self.node_type_id is not None: body['node_type_id'] = self.node_type_id
+        if self.num_cores is not None: body['num_cores'] = self.num_cores
+        if self.num_gpus is not None: body['num_gpus'] = self.num_gpus
+        if self.photon_driver_capable is not None: body['photon_driver_capable'] = self.photon_driver_capable
+        if self.photon_worker_capable is not None: body['photon_worker_capable'] = self.photon_worker_capable
+        if self.support_cluster_tags is not None: body['support_cluster_tags'] = self.support_cluster_tags
+        if self.support_ebs_volumes is not None: body['support_ebs_volumes'] = self.support_ebs_volumes
+        if self.support_port_forwarding is not None:
+            body['support_port_forwarding'] = self.support_port_forwarding
+        if self.supports_elastic_disk is not None: body['supports_elastic_disk'] = self.supports_elastic_disk
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> NodeType:
         """Deserializes the NodeType from a dictionary."""
@@ -5256,6 +6465,13 @@ class PendingInstanceError:
         if self.message is not None: body['message'] = self.message
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PendingInstanceError into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.instance_id is not None: body['instance_id'] = self.instance_id
+        if self.message is not None: body['message'] = self.message
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> PendingInstanceError:
         """Deserializes the PendingInstanceError from a dictionary."""
@@ -5273,6 +6489,12 @@ class PermanentDeleteCluster:
         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."""
@@ -5287,6 +6509,11 @@ class PermanentDeleteClusterResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PermanentDeleteClusterResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> PermanentDeleteClusterResponse:
         """Deserializes the PermanentDeleteClusterResponse from a dictionary."""
@@ -5304,6 +6531,12 @@ class PinCluster:
         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."""
@@ -5318,6 +6551,11 @@ class PinClusterResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PinClusterResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> PinClusterResponse:
         """Deserializes the PinClusterResponse from a dictionary."""
@@ -5395,6 +6633,23 @@ class Policy:
         if self.policy_id is not None: body['policy_id'] = self.policy_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Policy into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.created_at_timestamp is not None: body['created_at_timestamp'] = self.created_at_timestamp
+        if self.creator_user_name is not None: body['creator_user_name'] = self.creator_user_name
+        if self.definition is not None: body['definition'] = self.definition
+        if self.description is not None: body['description'] = self.description
+        if self.is_default is not None: body['is_default'] = self.is_default
+        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]) -> Policy:
         """Deserializes the Policy from a dictionary."""
@@ -5436,6 +6691,15 @@ class PolicyFamily:
         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 PolicyFamily 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.name is not None: body['name'] = self.name
+        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]) -> PolicyFamily:
         """Deserializes the PolicyFamily from a dictionary."""
@@ -5461,6 +6725,13 @@ class PythonPyPiLibrary:
         if self.repo is not None: body['repo'] = self.repo
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PythonPyPiLibrary into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.package is not None: body['package'] = self.package
+        if self.repo is not None: body['repo'] = self.repo
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> PythonPyPiLibrary:
         """Deserializes the PythonPyPiLibrary from a dictionary."""
@@ -5482,6 +6753,13 @@ class RCranLibrary:
         if self.repo is not None: body['repo'] = self.repo
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the RCranLibrary into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.package is not None: body['package'] = self.package
+        if self.repo is not None: body['repo'] = self.repo
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> RCranLibrary:
         """Deserializes the RCranLibrary from a dictionary."""
@@ -5499,6 +6777,12 @@ class RemoveInstanceProfile:
         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."""
@@ -5513,6 +6797,11 @@ class RemoveResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the RemoveResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> RemoveResponse:
         """Deserializes the RemoveResponse from a dictionary."""
@@ -5546,6 +6835,14 @@ class ResizeCluster:
         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."""
@@ -5562,6 +6859,11 @@ class ResizeClusterResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ResizeClusterResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ResizeClusterResponse:
         """Deserializes the ResizeClusterResponse from a dictionary."""
@@ -5583,6 +6885,13 @@ class RestartCluster:
         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."""
@@ -5597,6 +6906,11 @@ class RestartClusterResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the RestartClusterResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> RestartClusterResponse:
         """Deserializes the RestartClusterResponse from a dictionary."""
@@ -5656,6 +6970,21 @@ class Results:
         if self.truncated is not None: body['truncated'] = self.truncated
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Results into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.cause is not None: body['cause'] = self.cause
+        if self.data: body['data'] = self.data
+        if self.file_name is not None: body['fileName'] = self.file_name
+        if self.file_names: body['fileNames'] = self.file_names
+        if self.is_json_schema is not None: body['isJsonSchema'] = self.is_json_schema
+        if self.pos is not None: body['pos'] = self.pos
+        if self.result_type is not None: body['resultType'] = self.result_type
+        if self.schema: body['schema'] = self.schema
+        if self.summary is not None: body['summary'] = self.summary
+        if self.truncated is not None: body['truncated'] = self.truncated
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> Results:
         """Deserializes the Results from a dictionary."""
@@ -5732,6 +7061,18 @@ class S3StorageInfo:
         if self.region is not None: body['region'] = self.region
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the S3StorageInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.canned_acl is not None: body['canned_acl'] = self.canned_acl
+        if self.destination is not None: body['destination'] = self.destination
+        if self.enable_encryption is not None: body['enable_encryption'] = self.enable_encryption
+        if self.encryption_type is not None: body['encryption_type'] = self.encryption_type
+        if self.endpoint is not None: body['endpoint'] = self.endpoint
+        if self.kms_key is not None: body['kms_key'] = self.kms_key
+        if self.region is not None: body['region'] = self.region
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> S3StorageInfo:
         """Deserializes the S3StorageInfo from a dictionary."""
@@ -5788,6 +7129,18 @@ class SparkNode:
         if self.start_timestamp is not None: body['start_timestamp'] = self.start_timestamp
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the SparkNode into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.host_private_ip is not None: body['host_private_ip'] = self.host_private_ip
+        if self.instance_id is not None: body['instance_id'] = self.instance_id
+        if self.node_aws_attributes: body['node_aws_attributes'] = self.node_aws_attributes
+        if self.node_id is not None: body['node_id'] = self.node_id
+        if self.private_ip is not None: body['private_ip'] = self.private_ip
+        if self.public_dns is not None: body['public_dns'] = self.public_dns
+        if self.start_timestamp is not None: body['start_timestamp'] = self.start_timestamp
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> SparkNode:
         """Deserializes the SparkNode from a dictionary."""
@@ -5811,6 +7164,12 @@ class SparkNodeAwsAttributes:
         if self.is_spot is not None: body['is_spot'] = self.is_spot
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the SparkNodeAwsAttributes into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.is_spot is not None: body['is_spot'] = self.is_spot
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> SparkNodeAwsAttributes:
         """Deserializes the SparkNodeAwsAttributes from a dictionary."""
@@ -5835,6 +7194,13 @@ class SparkVersion:
         if self.name is not None: body['name'] = self.name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the SparkVersion into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.key is not None: body['key'] = self.key
+        if self.name is not None: body['name'] = self.name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> SparkVersion:
         """Deserializes the SparkVersion from a dictionary."""
@@ -5852,6 +7218,12 @@ class StartCluster:
         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."""
@@ -5866,6 +7238,11 @@ class StartClusterResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the StartClusterResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> StartClusterResponse:
         """Deserializes the StartClusterResponse from a dictionary."""
@@ -5904,6 +7281,14 @@ class TerminationReason:
         if self.type is not None: body['type'] = self.type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the TerminationReason into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.code is not None: body['code'] = self.code
+        if self.parameters: body['parameters'] = self.parameters
+        if self.type is not None: body['type'] = self.type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> TerminationReason:
         """Deserializes the TerminationReason from a dictionary."""
@@ -6020,6 +7405,13 @@ class UninstallLibraries:
         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."""
@@ -6034,6 +7426,11 @@ class UninstallLibrariesResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UninstallLibrariesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UninstallLibrariesResponse:
         """Deserializes the UninstallLibrariesResponse from a dictionary."""
@@ -6051,6 +7448,12 @@ class UnpinCluster:
         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."""
@@ -6065,6 +7468,11 @@ class UnpinClusterResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UnpinClusterResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UnpinClusterResponse:
         """Deserializes the UnpinClusterResponse from a dictionary."""
@@ -6093,6 +7501,14 @@ class UpdateCluster:
         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."""
@@ -6285,6 +7701,40 @@ class UpdateClusterResource:
         if self.workload_type: body['workload_type'] = self.workload_type.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateClusterResource into a shallow dictionary of its immediate attributes."""
+        body = {}
+        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_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.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.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.workload_type: body['workload_type'] = self.workload_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateClusterResource:
         """Deserializes the UpdateClusterResource from a dictionary."""
@@ -6324,6 +7774,11 @@ class UpdateClusterResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateClusterResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateClusterResponse:
         """Deserializes the UpdateClusterResponse from a dictionary."""
@@ -6338,6 +7793,11 @@ class UpdateResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateResponse:
         """Deserializes the UpdateResponse from a dictionary."""
@@ -6355,6 +7815,12 @@ class VolumesStorageInfo:
         if self.destination is not None: body['destination'] = self.destination
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the VolumesStorageInfo 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]) -> VolumesStorageInfo:
         """Deserializes the VolumesStorageInfo from a dictionary."""
@@ -6372,6 +7838,12 @@ class WorkloadType:
         if self.clients: body['clients'] = self.clients.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the WorkloadType into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.clients: body['clients'] = self.clients
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> WorkloadType:
         """Deserializes the WorkloadType from a dictionary."""
@@ -6389,6 +7861,12 @@ class WorkspaceStorageInfo:
         if self.destination is not None: body['destination'] = self.destination
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the WorkspaceStorageInfo 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]) -> WorkspaceStorageInfo:
         """Deserializes the WorkspaceStorageInfo from a dictionary."""