databricks-sdk 0.38.0__py3-none-any.whl → 0.40.0__py3-none-any.whl

databricks/sdk/service/sql.py

@@ -36,6 +36,14 @@ class AccessControl:
         if self.user_name is not None: body['user_name'] = self.user_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AccessControl 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.user_name is not None: body['user_name'] = self.user_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AccessControl:
         """Deserializes the AccessControl from a dictionary."""
@@ -118,6 +126,26 @@ class Alert:
         if self.update_time is not None: body['update_time'] = self.update_time
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Alert into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.condition: body['condition'] = self.condition
+        if self.create_time is not None: body['create_time'] = self.create_time
+        if self.custom_body is not None: body['custom_body'] = self.custom_body
+        if self.custom_subject is not None: body['custom_subject'] = self.custom_subject
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.id is not None: body['id'] = self.id
+        if self.lifecycle_state is not None: body['lifecycle_state'] = self.lifecycle_state
+        if self.notify_on_ok is not None: body['notify_on_ok'] = self.notify_on_ok
+        if self.owner_user_name is not None: body['owner_user_name'] = self.owner_user_name
+        if self.parent_path is not None: body['parent_path'] = self.parent_path
+        if self.query_id is not None: body['query_id'] = self.query_id
+        if self.seconds_to_retrigger is not None: body['seconds_to_retrigger'] = self.seconds_to_retrigger
+        if self.state is not None: body['state'] = self.state
+        if self.trigger_time is not None: body['trigger_time'] = self.trigger_time
+        if self.update_time is not None: body['update_time'] = self.update_time
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> Alert:
         """Deserializes the Alert from a dictionary."""
@@ -161,6 +189,15 @@ class AlertCondition:
         if self.threshold: body['threshold'] = self.threshold.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AlertCondition into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.empty_result_state is not None: body['empty_result_state'] = self.empty_result_state
+        if self.op is not None: body['op'] = self.op
+        if self.operand: body['operand'] = self.operand
+        if self.threshold: body['threshold'] = self.threshold
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AlertCondition:
         """Deserializes the AlertCondition from a dictionary."""
@@ -180,6 +217,12 @@ class AlertConditionOperand:
         if self.column: body['column'] = self.column.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AlertConditionOperand into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.column: body['column'] = self.column
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AlertConditionOperand:
         """Deserializes the AlertConditionOperand from a dictionary."""
@@ -196,6 +239,12 @@ class AlertConditionThreshold:
         if self.value: body['value'] = self.value.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AlertConditionThreshold into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.value: body['value'] = self.value
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AlertConditionThreshold:
         """Deserializes the AlertConditionThreshold from a dictionary."""
@@ -212,6 +261,12 @@ class AlertOperandColumn:
         if self.name is not None: body['name'] = self.name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AlertOperandColumn into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.name is not None: body['name'] = self.name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AlertOperandColumn:
         """Deserializes the AlertOperandColumn from a dictionary."""
@@ -234,6 +289,14 @@ class AlertOperandValue:
         if self.string_value is not None: body['string_value'] = self.string_value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AlertOperandValue into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.bool_value is not None: body['bool_value'] = self.bool_value
+        if self.double_value is not None: body['double_value'] = self.double_value
+        if self.string_value is not None: body['string_value'] = self.string_value
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AlertOperandValue:
         """Deserializes the AlertOperandValue from a dictionary."""
@@ -297,6 +360,18 @@ class AlertOptions:
         if self.value: body['value'] = self.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AlertOptions into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.column is not None: body['column'] = self.column
+        if self.custom_body is not None: body['custom_body'] = self.custom_body
+        if self.custom_subject is not None: body['custom_subject'] = self.custom_subject
+        if self.empty_result_state is not None: body['empty_result_state'] = self.empty_result_state
+        if self.muted is not None: body['muted'] = self.muted
+        if self.op is not None: body['op'] = self.op
+        if self.value: body['value'] = self.value
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AlertOptions:
         """Deserializes the AlertOptions from a dictionary."""
@@ -382,6 +457,24 @@ class AlertQuery:
         if self.user_id is not None: body['user_id'] = self.user_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AlertQuery into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.data_source_id is not None: body['data_source_id'] = self.data_source_id
+        if self.description is not None: body['description'] = self.description
+        if self.id is not None: body['id'] = self.id
+        if self.is_archived is not None: body['is_archived'] = self.is_archived
+        if self.is_draft is not None: body['is_draft'] = self.is_draft
+        if self.is_safe is not None: body['is_safe'] = self.is_safe
+        if self.name is not None: body['name'] = self.name
+        if self.options: body['options'] = self.options
+        if self.query is not None: body['query'] = self.query
+        if self.tags: body['tags'] = self.tags
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.user_id is not None: body['user_id'] = self.user_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AlertQuery:
         """Deserializes the AlertQuery from a dictionary."""
@@ -434,6 +527,15 @@ class BaseChunkInfo:
         if self.row_offset is not None: body['row_offset'] = self.row_offset
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the BaseChunkInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.byte_count is not None: body['byte_count'] = self.byte_count
+        if self.chunk_index is not None: body['chunk_index'] = self.chunk_index
+        if self.row_count is not None: body['row_count'] = self.row_count
+        if self.row_offset is not None: body['row_offset'] = self.row_offset
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> BaseChunkInfo:
         """Deserializes the BaseChunkInfo from a dictionary."""
@@ -451,6 +553,11 @@ class CancelExecutionResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CancelExecutionResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CancelExecutionResponse:
         """Deserializes the CancelExecutionResponse from a dictionary."""
@@ -473,6 +580,13 @@ class Channel:
         if self.name is not None: body['name'] = self.name.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Channel into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.dbsql_version is not None: body['dbsql_version'] = self.dbsql_version
+        if self.name is not None: body['name'] = self.name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> Channel:
         """Deserializes the Channel from a dictionary."""
@@ -496,6 +610,13 @@ class ChannelInfo:
         if self.name is not None: body['name'] = self.name.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ChannelInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.dbsql_version is not None: body['dbsql_version'] = self.dbsql_version
+        if self.name is not None: body['name'] = self.name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ChannelInfo:
         """Deserializes the ChannelInfo from a dictionary."""
@@ -547,6 +668,18 @@ class ColumnInfo:
         if self.type_text is not None: body['type_text'] = self.type_text
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ColumnInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.name is not None: body['name'] = self.name
+        if self.position is not None: body['position'] = self.position
+        if self.type_interval_type is not None: body['type_interval_type'] = self.type_interval_type
+        if self.type_name is not None: body['type_name'] = self.type_name
+        if self.type_precision is not None: body['type_precision'] = self.type_precision
+        if self.type_scale is not None: body['type_scale'] = self.type_scale
+        if self.type_text is not None: body['type_text'] = self.type_text
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ColumnInfo:
         """Deserializes the ColumnInfo from a dictionary."""
@@ -612,6 +745,16 @@ class CreateAlert:
         if self.rearm is not None: body['rearm'] = self.rearm
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateAlert into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.name is not None: body['name'] = self.name
+        if self.options: body['options'] = self.options
+        if self.parent is not None: body['parent'] = self.parent
+        if self.query_id is not None: body['query_id'] = self.query_id
+        if self.rearm is not None: body['rearm'] = self.rearm
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateAlert:
         """Deserializes the CreateAlert from a dictionary."""
@@ -632,6 +775,12 @@ class CreateAlertRequest:
         if self.alert: body['alert'] = self.alert.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateAlertRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.alert: body['alert'] = self.alert
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateAlertRequest:
         """Deserializes the CreateAlertRequest from a dictionary."""
@@ -683,6 +832,19 @@ class CreateAlertRequestAlert:
         if self.seconds_to_retrigger is not None: body['seconds_to_retrigger'] = self.seconds_to_retrigger
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateAlertRequestAlert into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.condition: body['condition'] = self.condition
+        if self.custom_body is not None: body['custom_body'] = self.custom_body
+        if self.custom_subject is not None: body['custom_subject'] = self.custom_subject
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.notify_on_ok is not None: body['notify_on_ok'] = self.notify_on_ok
+        if self.parent_path is not None: body['parent_path'] = self.parent_path
+        if self.query_id is not None: body['query_id'] = self.query_id
+        if self.seconds_to_retrigger is not None: body['seconds_to_retrigger'] = self.seconds_to_retrigger
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateAlertRequestAlert:
         """Deserializes the CreateAlertRequestAlert from a dictionary."""
@@ -706,6 +868,12 @@ class CreateQueryRequest:
         if self.query: body['query'] = self.query.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateQueryRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.query: body['query'] = self.query
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateQueryRequest:
         """Deserializes the CreateQueryRequest from a dictionary."""
@@ -762,6 +930,22 @@ class CreateQueryRequestQuery:
         if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateQueryRequestQuery into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.apply_auto_limit is not None: body['apply_auto_limit'] = self.apply_auto_limit
+        if self.catalog is not None: body['catalog'] = self.catalog
+        if self.description is not None: body['description'] = self.description
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.parameters: body['parameters'] = self.parameters
+        if self.parent_path is not None: body['parent_path'] = self.parent_path
+        if self.query_text is not None: body['query_text'] = self.query_text
+        if self.run_as_mode is not None: body['run_as_mode'] = self.run_as_mode
+        if self.schema is not None: body['schema'] = self.schema
+        if self.tags: body['tags'] = self.tags
+        if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateQueryRequestQuery:
         """Deserializes the CreateQueryRequestQuery from a dictionary."""
@@ -788,6 +972,12 @@ class CreateVisualizationRequest:
         if self.visualization: body['visualization'] = self.visualization.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateVisualizationRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.visualization: body['visualization'] = self.visualization
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateVisualizationRequest:
         """Deserializes the CreateVisualizationRequest from a dictionary."""
@@ -823,6 +1013,16 @@ class CreateVisualizationRequestVisualization:
         if self.type is not None: body['type'] = self.type
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateVisualizationRequestVisualization into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.query_id is not None: body['query_id'] = self.query_id
+        if self.serialized_options is not None: body['serialized_options'] = self.serialized_options
+        if self.serialized_query_plan is not None: body['serialized_query_plan'] = self.serialized_query_plan
+        if self.type is not None: body['type'] = self.type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateVisualizationRequestVisualization:
         """Deserializes the CreateVisualizationRequestVisualization from a dictionary."""
@@ -924,6 +1124,25 @@ class CreateWarehouseRequest:
         if self.warehouse_type is not None: body['warehouse_type'] = self.warehouse_type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateWarehouseRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.auto_stop_mins is not None: body['auto_stop_mins'] = self.auto_stop_mins
+        if self.channel: body['channel'] = self.channel
+        if self.cluster_size is not None: body['cluster_size'] = self.cluster_size
+        if self.creator_name is not None: body['creator_name'] = self.creator_name
+        if self.enable_photon is not None: body['enable_photon'] = self.enable_photon
+        if self.enable_serverless_compute is not None:
+            body['enable_serverless_compute'] = self.enable_serverless_compute
+        if self.instance_profile_arn is not None: body['instance_profile_arn'] = self.instance_profile_arn
+        if self.max_num_clusters is not None: body['max_num_clusters'] = self.max_num_clusters
+        if self.min_num_clusters is not None: body['min_num_clusters'] = self.min_num_clusters
+        if self.name is not None: body['name'] = self.name
+        if self.spot_instance_policy is not None: body['spot_instance_policy'] = self.spot_instance_policy
+        if self.tags: body['tags'] = self.tags
+        if self.warehouse_type is not None: body['warehouse_type'] = self.warehouse_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateWarehouseRequest:
         """Deserializes the CreateWarehouseRequest from a dictionary."""
@@ -962,6 +1181,12 @@ class CreateWarehouseResponse:
         if self.id is not None: body['id'] = self.id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateWarehouseResponse 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]) -> CreateWarehouseResponse:
         """Deserializes the CreateWarehouseResponse from a dictionary."""
@@ -999,6 +1224,17 @@ class CreateWidget:
         if self.width is not None: body['width'] = self.width
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateWidget into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.dashboard_id is not None: body['dashboard_id'] = self.dashboard_id
+        if self.id is not None: body['id'] = self.id
+        if self.options: body['options'] = self.options
+        if self.text is not None: body['text'] = self.text
+        if self.visualization_id is not None: body['visualization_id'] = self.visualization_id
+        if self.width is not None: body['width'] = self.width
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateWidget:
         """Deserializes the CreateWidget from a dictionary."""
@@ -1090,6 +1326,29 @@ class Dashboard:
         if self.widgets: body['widgets'] = [v.as_dict() for v in self.widgets]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Dashboard into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.can_edit is not None: body['can_edit'] = self.can_edit
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.dashboard_filters_enabled is not None:
+            body['dashboard_filters_enabled'] = self.dashboard_filters_enabled
+        if self.id is not None: body['id'] = self.id
+        if self.is_archived is not None: body['is_archived'] = self.is_archived
+        if self.is_draft is not None: body['is_draft'] = self.is_draft
+        if self.is_favorite is not None: body['is_favorite'] = self.is_favorite
+        if self.name is not None: body['name'] = self.name
+        if self.options: body['options'] = self.options
+        if self.parent is not None: body['parent'] = self.parent
+        if self.permission_tier is not None: body['permission_tier'] = self.permission_tier
+        if self.slug is not None: body['slug'] = self.slug
+        if self.tags: body['tags'] = self.tags
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.user: body['user'] = self.user
+        if self.user_id is not None: body['user_id'] = self.user_id
+        if self.widgets: body['widgets'] = self.widgets
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> Dashboard:
         """Deserializes the Dashboard from a dictionary."""
@@ -1134,6 +1393,15 @@ class DashboardEditContent:
         if self.tags: body['tags'] = [v for v in self.tags]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DashboardEditContent into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.dashboard_id is not None: body['dashboard_id'] = self.dashboard_id
+        if self.name is not None: body['name'] = self.name
+        if self.run_as_role is not None: body['run_as_role'] = self.run_as_role
+        if self.tags: body['tags'] = self.tags
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DashboardEditContent:
         """Deserializes the DashboardEditContent from a dictionary."""
@@ -1155,6 +1423,12 @@ class DashboardOptions:
         if self.moved_to_trash_at is not None: body['moved_to_trash_at'] = self.moved_to_trash_at
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DashboardOptions into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.moved_to_trash_at is not None: body['moved_to_trash_at'] = self.moved_to_trash_at
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DashboardOptions:
         """Deserializes the DashboardOptions from a dictionary."""
@@ -1193,6 +1467,18 @@ class DashboardPostContent:
         if self.tags: body['tags'] = [v for v in self.tags]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DashboardPostContent into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.dashboard_filters_enabled is not None:
+            body['dashboard_filters_enabled'] = self.dashboard_filters_enabled
+        if self.is_favorite is not None: body['is_favorite'] = self.is_favorite
+        if self.name is not None: body['name'] = self.name
+        if self.parent is not None: body['parent'] = self.parent
+        if self.run_as_role is not None: body['run_as_role'] = self.run_as_role
+        if self.tags: body['tags'] = self.tags
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DashboardPostContent:
         """Deserializes the DashboardPostContent from a dictionary."""
@@ -1253,6 +1539,20 @@ class DataSource:
         if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DataSource into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.id is not None: body['id'] = self.id
+        if self.name is not None: body['name'] = self.name
+        if self.pause_reason is not None: body['pause_reason'] = self.pause_reason
+        if self.paused is not None: body['paused'] = self.paused
+        if self.supports_auto_limit is not None: body['supports_auto_limit'] = self.supports_auto_limit
+        if self.syntax is not None: body['syntax'] = self.syntax
+        if self.type is not None: body['type'] = self.type
+        if self.view_only is not None: body['view_only'] = self.view_only
+        if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DataSource:
         """Deserializes the DataSource from a dictionary."""
@@ -1287,6 +1587,13 @@ class DateRange:
         if self.start is not None: body['start'] = self.start
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DateRange into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.end is not None: body['end'] = self.end
+        if self.start is not None: body['start'] = self.start
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DateRange:
         """Deserializes the DateRange from a dictionary."""
@@ -1317,6 +1624,16 @@ class DateRangeValue:
         if self.start_day_of_week is not None: body['start_day_of_week'] = self.start_day_of_week
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DateRangeValue into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.date_range_value: body['date_range_value'] = self.date_range_value
+        if self.dynamic_date_range_value is not None:
+            body['dynamic_date_range_value'] = self.dynamic_date_range_value
+        if self.precision is not None: body['precision'] = self.precision
+        if self.start_day_of_week is not None: body['start_day_of_week'] = self.start_day_of_week
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DateRangeValue:
         """Deserializes the DateRangeValue from a dictionary."""
@@ -1368,6 +1685,14 @@ class DateValue:
         if self.precision is not None: body['precision'] = self.precision.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DateValue into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.date_value is not None: body['date_value'] = self.date_value
+        if self.dynamic_date_value is not None: body['dynamic_date_value'] = self.dynamic_date_value
+        if self.precision is not None: body['precision'] = self.precision
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DateValue:
         """Deserializes the DateValue from a dictionary."""
@@ -1390,6 +1715,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."""
@@ -1404,6 +1734,11 @@ class DeleteWarehouseResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeleteWarehouseResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DeleteWarehouseResponse:
         """Deserializes the DeleteWarehouseResponse from a dictionary."""
@@ -1443,6 +1778,16 @@ class EditAlert:
         if self.rearm is not None: body['rearm'] = self.rearm
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EditAlert into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.alert_id is not None: body['alert_id'] = self.alert_id
+        if self.name is not None: body['name'] = self.name
+        if self.options: body['options'] = self.options
+        if self.query_id is not None: body['query_id'] = self.query_id
+        if self.rearm is not None: body['rearm'] = self.rearm
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EditAlert:
         """Deserializes the EditAlert from a dictionary."""
@@ -1547,6 +1892,26 @@ class EditWarehouseRequest:
         if self.warehouse_type is not None: body['warehouse_type'] = self.warehouse_type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EditWarehouseRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.auto_stop_mins is not None: body['auto_stop_mins'] = self.auto_stop_mins
+        if self.channel: body['channel'] = self.channel
+        if self.cluster_size is not None: body['cluster_size'] = self.cluster_size
+        if self.creator_name is not None: body['creator_name'] = self.creator_name
+        if self.enable_photon is not None: body['enable_photon'] = self.enable_photon
+        if self.enable_serverless_compute is not None:
+            body['enable_serverless_compute'] = self.enable_serverless_compute
+        if self.id is not None: body['id'] = self.id
+        if self.instance_profile_arn is not None: body['instance_profile_arn'] = self.instance_profile_arn
+        if self.max_num_clusters is not None: body['max_num_clusters'] = self.max_num_clusters
+        if self.min_num_clusters is not None: body['min_num_clusters'] = self.min_num_clusters
+        if self.name is not None: body['name'] = self.name
+        if self.spot_instance_policy is not None: body['spot_instance_policy'] = self.spot_instance_policy
+        if self.tags: body['tags'] = self.tags
+        if self.warehouse_type is not None: body['warehouse_type'] = self.warehouse_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EditWarehouseRequest:
         """Deserializes the EditWarehouseRequest from a dictionary."""
@@ -1583,6 +1948,11 @@ class EditWarehouseResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EditWarehouseResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EditWarehouseResponse:
         """Deserializes the EditWarehouseResponse from a dictionary."""
@@ -1599,6 +1969,11 @@ class Empty:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Empty into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> Empty:
         """Deserializes the Empty from a dictionary."""
@@ -1618,6 +1993,13 @@ class EndpointConfPair:
         if self.value is not None: body['value'] = self.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EndpointConfPair into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.key is not None: body['key'] = self.key
+        if self.value is not None: body['value'] = self.value
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EndpointConfPair:
         """Deserializes the EndpointConfPair from a dictionary."""
@@ -1652,6 +2034,16 @@ class EndpointHealth:
         if self.summary is not None: body['summary'] = self.summary
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EndpointHealth into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.details is not None: body['details'] = self.details
+        if self.failure_reason: body['failure_reason'] = self.failure_reason
+        if self.message is not None: body['message'] = self.message
+        if self.status is not None: body['status'] = self.status
+        if self.summary is not None: body['summary'] = self.summary
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EndpointHealth:
         """Deserializes the EndpointHealth from a dictionary."""
@@ -1780,6 +2172,32 @@ class EndpointInfo:
         if self.warehouse_type is not None: body['warehouse_type'] = self.warehouse_type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EndpointInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.auto_stop_mins is not None: body['auto_stop_mins'] = self.auto_stop_mins
+        if self.channel: body['channel'] = self.channel
+        if self.cluster_size is not None: body['cluster_size'] = self.cluster_size
+        if self.creator_name is not None: body['creator_name'] = self.creator_name
+        if self.enable_photon is not None: body['enable_photon'] = self.enable_photon
+        if self.enable_serverless_compute is not None:
+            body['enable_serverless_compute'] = self.enable_serverless_compute
+        if self.health: body['health'] = self.health
+        if self.id is not None: body['id'] = self.id
+        if self.instance_profile_arn is not None: body['instance_profile_arn'] = self.instance_profile_arn
+        if self.jdbc_url is not None: body['jdbc_url'] = self.jdbc_url
+        if self.max_num_clusters is not None: body['max_num_clusters'] = self.max_num_clusters
+        if self.min_num_clusters is not None: body['min_num_clusters'] = self.min_num_clusters
+        if self.name is not None: body['name'] = self.name
+        if self.num_active_sessions is not None: body['num_active_sessions'] = self.num_active_sessions
+        if self.num_clusters is not None: body['num_clusters'] = self.num_clusters
+        if self.odbc_params: body['odbc_params'] = self.odbc_params
+        if self.spot_instance_policy is not None: body['spot_instance_policy'] = self.spot_instance_policy
+        if self.state is not None: body['state'] = self.state
+        if self.tags: body['tags'] = self.tags
+        if self.warehouse_type is not None: body['warehouse_type'] = self.warehouse_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EndpointInfo:
         """Deserializes the EndpointInfo from a dictionary."""
@@ -1827,6 +2245,13 @@ class EndpointTagPair:
         if self.value is not None: body['value'] = self.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EndpointTagPair into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.key is not None: body['key'] = self.key
+        if self.value is not None: body['value'] = self.value
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EndpointTagPair:
         """Deserializes the EndpointTagPair from a dictionary."""
@@ -1843,6 +2268,12 @@ class EndpointTags:
         if self.custom_tags: body['custom_tags'] = [v.as_dict() for v in self.custom_tags]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EndpointTags into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.custom_tags: body['custom_tags'] = self.custom_tags
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EndpointTags:
         """Deserializes the EndpointTags from a dictionary."""
@@ -1868,6 +2299,14 @@ class EnumValue:
         if self.values: body['values'] = [v for v in self.values]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EnumValue into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.enum_options is not None: body['enum_options'] = self.enum_options
+        if self.multi_values_options: body['multi_values_options'] = self.multi_values_options
+        if self.values: body['values'] = self.values
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EnumValue:
         """Deserializes the EnumValue from a dictionary."""
@@ -2009,6 +2448,22 @@ class ExecuteStatementRequest:
         if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ExecuteStatementRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.byte_limit is not None: body['byte_limit'] = self.byte_limit
+        if self.catalog is not None: body['catalog'] = self.catalog
+        if self.disposition is not None: body['disposition'] = self.disposition
+        if self.format is not None: body['format'] = self.format
+        if self.on_wait_timeout is not None: body['on_wait_timeout'] = self.on_wait_timeout
+        if self.parameters: body['parameters'] = self.parameters
+        if self.row_limit is not None: body['row_limit'] = self.row_limit
+        if self.schema is not None: body['schema'] = self.schema
+        if self.statement is not None: body['statement'] = self.statement
+        if self.wait_timeout is not None: body['wait_timeout'] = self.wait_timeout
+        if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ExecuteStatementRequest:
         """Deserializes the ExecuteStatementRequest from a dictionary."""
@@ -2089,6 +2544,21 @@ class ExternalLink:
         if self.row_offset is not None: body['row_offset'] = self.row_offset
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ExternalLink into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.byte_count is not None: body['byte_count'] = self.byte_count
+        if self.chunk_index is not None: body['chunk_index'] = self.chunk_index
+        if self.expiration is not None: body['expiration'] = self.expiration
+        if self.external_link is not None: body['external_link'] = self.external_link
+        if self.http_headers: body['http_headers'] = self.http_headers
+        if self.next_chunk_index is not None: body['next_chunk_index'] = self.next_chunk_index
+        if self.next_chunk_internal_link is not None:
+            body['next_chunk_internal_link'] = self.next_chunk_internal_link
+        if self.row_count is not None: body['row_count'] = self.row_count
+        if self.row_offset is not None: body['row_offset'] = self.row_offset
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ExternalLink:
         """Deserializes the ExternalLink from a dictionary."""
@@ -2129,6 +2599,14 @@ class GetResponse:
         if self.object_type is not None: body['object_type'] = self.object_type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GetResponse 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]) -> GetResponse:
         """Deserializes the GetResponse from a dictionary."""
@@ -2148,6 +2626,12 @@ class GetWarehousePermissionLevelsResponse:
         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 GetWarehousePermissionLevelsResponse 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]) -> GetWarehousePermissionLevelsResponse:
         """Deserializes the GetWarehousePermissionLevelsResponse from a dictionary."""
@@ -2272,6 +2756,32 @@ class GetWarehouseResponse:
         if self.warehouse_type is not None: body['warehouse_type'] = self.warehouse_type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GetWarehouseResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.auto_stop_mins is not None: body['auto_stop_mins'] = self.auto_stop_mins
+        if self.channel: body['channel'] = self.channel
+        if self.cluster_size is not None: body['cluster_size'] = self.cluster_size
+        if self.creator_name is not None: body['creator_name'] = self.creator_name
+        if self.enable_photon is not None: body['enable_photon'] = self.enable_photon
+        if self.enable_serverless_compute is not None:
+            body['enable_serverless_compute'] = self.enable_serverless_compute
+        if self.health: body['health'] = self.health
+        if self.id is not None: body['id'] = self.id
+        if self.instance_profile_arn is not None: body['instance_profile_arn'] = self.instance_profile_arn
+        if self.jdbc_url is not None: body['jdbc_url'] = self.jdbc_url
+        if self.max_num_clusters is not None: body['max_num_clusters'] = self.max_num_clusters
+        if self.min_num_clusters is not None: body['min_num_clusters'] = self.min_num_clusters
+        if self.name is not None: body['name'] = self.name
+        if self.num_active_sessions is not None: body['num_active_sessions'] = self.num_active_sessions
+        if self.num_clusters is not None: body['num_clusters'] = self.num_clusters
+        if self.odbc_params: body['odbc_params'] = self.odbc_params
+        if self.spot_instance_policy is not None: body['spot_instance_policy'] = self.spot_instance_policy
+        if self.state is not None: body['state'] = self.state
+        if self.tags: body['tags'] = self.tags
+        if self.warehouse_type is not None: body['warehouse_type'] = self.warehouse_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GetWarehouseResponse:
         """Deserializes the GetWarehouseResponse from a dictionary."""
@@ -2358,6 +2868,22 @@ class GetWorkspaceWarehouseConfigResponse:
             body['sql_configuration_parameters'] = self.sql_configuration_parameters.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GetWorkspaceWarehouseConfigResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.channel: body['channel'] = self.channel
+        if self.config_param: body['config_param'] = self.config_param
+        if self.data_access_config: body['data_access_config'] = self.data_access_config
+        if self.enabled_warehouse_types: body['enabled_warehouse_types'] = self.enabled_warehouse_types
+        if self.global_param: body['global_param'] = self.global_param
+        if self.google_service_account is not None:
+            body['google_service_account'] = self.google_service_account
+        if self.instance_profile_arn is not None: body['instance_profile_arn'] = self.instance_profile_arn
+        if self.security_policy is not None: body['security_policy'] = self.security_policy
+        if self.sql_configuration_parameters:
+            body['sql_configuration_parameters'] = self.sql_configuration_parameters
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GetWorkspaceWarehouseConfigResponse:
         """Deserializes the GetWorkspaceWarehouseConfigResponse from a dictionary."""
@@ -2433,6 +2959,22 @@ class LegacyAlert:
         if self.user: body['user'] = self.user.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the LegacyAlert into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.id is not None: body['id'] = self.id
+        if self.last_triggered_at is not None: body['last_triggered_at'] = self.last_triggered_at
+        if self.name is not None: body['name'] = self.name
+        if self.options: body['options'] = self.options
+        if self.parent is not None: body['parent'] = self.parent
+        if self.query: body['query'] = self.query
+        if self.rearm is not None: body['rearm'] = self.rearm
+        if self.state is not None: body['state'] = self.state
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.user: body['user'] = self.user
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> LegacyAlert:
         """Deserializes the LegacyAlert from a dictionary."""
@@ -2568,6 +3110,35 @@ class LegacyQuery:
         if self.visualizations: body['visualizations'] = [v.as_dict() for v in self.visualizations]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the LegacyQuery into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.can_edit is not None: body['can_edit'] = self.can_edit
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.data_source_id is not None: body['data_source_id'] = self.data_source_id
+        if self.description is not None: body['description'] = self.description
+        if self.id is not None: body['id'] = self.id
+        if self.is_archived is not None: body['is_archived'] = self.is_archived
+        if self.is_draft is not None: body['is_draft'] = self.is_draft
+        if self.is_favorite is not None: body['is_favorite'] = self.is_favorite
+        if self.is_safe is not None: body['is_safe'] = self.is_safe
+        if self.last_modified_by: body['last_modified_by'] = self.last_modified_by
+        if self.last_modified_by_id is not None: body['last_modified_by_id'] = self.last_modified_by_id
+        if self.latest_query_data_id is not None: body['latest_query_data_id'] = self.latest_query_data_id
+        if self.name is not None: body['name'] = self.name
+        if self.options: body['options'] = self.options
+        if self.parent is not None: body['parent'] = self.parent
+        if self.permission_tier is not None: body['permission_tier'] = self.permission_tier
+        if self.query is not None: body['query'] = self.query
+        if self.query_hash is not None: body['query_hash'] = self.query_hash
+        if self.run_as_role is not None: body['run_as_role'] = self.run_as_role
+        if self.tags: body['tags'] = self.tags
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.user: body['user'] = self.user
+        if self.user_id is not None: body['user_id'] = self.user_id
+        if self.visualizations: body['visualizations'] = self.visualizations
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> LegacyQuery:
         """Deserializes the LegacyQuery from a dictionary."""
@@ -2639,6 +3210,19 @@ class LegacyVisualization:
         if self.updated_at is not None: body['updated_at'] = self.updated_at
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the LegacyVisualization into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.description is not None: body['description'] = self.description
+        if self.id is not None: body['id'] = self.id
+        if self.name is not None: body['name'] = self.name
+        if self.options: body['options'] = self.options
+        if self.query: body['query'] = self.query
+        if self.type is not None: body['type'] = self.type
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> LegacyVisualization:
         """Deserializes the LegacyVisualization from a dictionary."""
@@ -2671,6 +3255,13 @@ class ListAlertsResponse:
         if self.results: body['results'] = [v.as_dict() for v in self.results]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListAlertsResponse 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.results: body['results'] = self.results
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListAlertsResponse:
         """Deserializes the ListAlertsResponse from a dictionary."""
@@ -2748,6 +3339,25 @@ class ListAlertsResponseAlert:
         if self.update_time is not None: body['update_time'] = self.update_time
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListAlertsResponseAlert into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.condition: body['condition'] = self.condition
+        if self.create_time is not None: body['create_time'] = self.create_time
+        if self.custom_body is not None: body['custom_body'] = self.custom_body
+        if self.custom_subject is not None: body['custom_subject'] = self.custom_subject
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.id is not None: body['id'] = self.id
+        if self.lifecycle_state is not None: body['lifecycle_state'] = self.lifecycle_state
+        if self.notify_on_ok is not None: body['notify_on_ok'] = self.notify_on_ok
+        if self.owner_user_name is not None: body['owner_user_name'] = self.owner_user_name
+        if self.query_id is not None: body['query_id'] = self.query_id
+        if self.seconds_to_retrigger is not None: body['seconds_to_retrigger'] = self.seconds_to_retrigger
+        if self.state is not None: body['state'] = self.state
+        if self.trigger_time is not None: body['trigger_time'] = self.trigger_time
+        if self.update_time is not None: body['update_time'] = self.update_time
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListAlertsResponseAlert:
         """Deserializes the ListAlertsResponseAlert from a dictionary."""
@@ -2791,6 +3401,14 @@ class ListQueriesResponse:
         if self.res: body['res'] = [v.as_dict() for v in self.res]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListQueriesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.has_next_page is not None: body['has_next_page'] = self.has_next_page
+        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.res: body['res'] = self.res
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListQueriesResponse:
         """Deserializes the ListQueriesResponse from a dictionary."""
@@ -2812,6 +3430,13 @@ class ListQueryObjectsResponse:
         if self.results: body['results'] = [v.as_dict() for v in self.results]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListQueryObjectsResponse 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.results: body['results'] = self.results
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListQueryObjectsResponse:
         """Deserializes the ListQueryObjectsResponse from a dictionary."""
@@ -2890,6 +3515,28 @@ class ListQueryObjectsResponseQuery:
         if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListQueryObjectsResponseQuery into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.apply_auto_limit is not None: body['apply_auto_limit'] = self.apply_auto_limit
+        if self.catalog is not None: body['catalog'] = self.catalog
+        if self.create_time is not None: body['create_time'] = self.create_time
+        if self.description is not None: body['description'] = self.description
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.id is not None: body['id'] = self.id
+        if self.last_modifier_user_name is not None:
+            body['last_modifier_user_name'] = self.last_modifier_user_name
+        if self.lifecycle_state is not None: body['lifecycle_state'] = self.lifecycle_state
+        if self.owner_user_name is not None: body['owner_user_name'] = self.owner_user_name
+        if self.parameters: body['parameters'] = self.parameters
+        if self.query_text is not None: body['query_text'] = self.query_text
+        if self.run_as_mode is not None: body['run_as_mode'] = self.run_as_mode
+        if self.schema is not None: body['schema'] = self.schema
+        if self.tags: body['tags'] = self.tags
+        if self.update_time is not None: body['update_time'] = self.update_time
+        if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListQueryObjectsResponseQuery:
         """Deserializes the ListQueryObjectsResponseQuery from a dictionary."""
@@ -2934,6 +3581,15 @@ class ListResponse:
         if self.results: body['results'] = [v.as_dict() for v in self.results]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.count is not None: body['count'] = self.count
+        if self.page is not None: body['page'] = self.page
+        if self.page_size is not None: body['page_size'] = self.page_size
+        if self.results: body['results'] = self.results
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListResponse:
         """Deserializes the ListResponse from a dictionary."""
@@ -2956,6 +3612,13 @@ class ListVisualizationsForQueryResponse:
         if self.results: body['results'] = [v.as_dict() for v in self.results]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListVisualizationsForQueryResponse 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.results: body['results'] = self.results
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListVisualizationsForQueryResponse:
         """Deserializes the ListVisualizationsForQueryResponse from a dictionary."""
@@ -2974,6 +3637,12 @@ class ListWarehousesResponse:
         if self.warehouses: body['warehouses'] = [v.as_dict() for v in self.warehouses]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListWarehousesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.warehouses: body['warehouses'] = self.warehouses
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListWarehousesResponse:
         """Deserializes the ListWarehousesResponse from a dictionary."""
@@ -2999,6 +3668,14 @@ class MultiValuesOptions:
         if self.suffix is not None: body['suffix'] = self.suffix
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the MultiValuesOptions into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.prefix is not None: body['prefix'] = self.prefix
+        if self.separator is not None: body['separator'] = self.separator
+        if self.suffix is not None: body['suffix'] = self.suffix
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> MultiValuesOptions:
         """Deserializes the MultiValuesOptions from a dictionary."""
@@ -3017,6 +3694,12 @@ class NumericValue:
         if self.value is not None: body['value'] = self.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the NumericValue into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.value is not None: body['value'] = self.value
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> NumericValue:
         """Deserializes the NumericValue from a dictionary."""
@@ -3060,6 +3743,15 @@ class OdbcParams:
         if self.protocol is not None: body['protocol'] = self.protocol
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the OdbcParams into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.hostname is not None: body['hostname'] = self.hostname
+        if self.path is not None: body['path'] = self.path
+        if self.port is not None: body['port'] = self.port
+        if self.protocol is not None: body['protocol'] = self.protocol
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> OdbcParams:
         """Deserializes the OdbcParams from a dictionary."""
@@ -3114,6 +3806,18 @@ class Parameter:
         if self.value: body['value'] = self.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Parameter into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.enum_options is not None: body['enumOptions'] = self.enum_options
+        if self.multi_values_options: body['multiValuesOptions'] = self.multi_values_options
+        if self.name is not None: body['name'] = self.name
+        if self.query_id is not None: body['queryId'] = self.query_id
+        if self.title is not None: body['title'] = self.title
+        if self.type is not None: body['type'] = self.type
+        if self.value: body['value'] = self.value
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> Parameter:
         """Deserializes the Parameter from a dictionary."""
@@ -3232,6 +3936,29 @@ class Query:
         if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Query into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.apply_auto_limit is not None: body['apply_auto_limit'] = self.apply_auto_limit
+        if self.catalog is not None: body['catalog'] = self.catalog
+        if self.create_time is not None: body['create_time'] = self.create_time
+        if self.description is not None: body['description'] = self.description
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.id is not None: body['id'] = self.id
+        if self.last_modifier_user_name is not None:
+            body['last_modifier_user_name'] = self.last_modifier_user_name
+        if self.lifecycle_state is not None: body['lifecycle_state'] = self.lifecycle_state
+        if self.owner_user_name is not None: body['owner_user_name'] = self.owner_user_name
+        if self.parameters: body['parameters'] = self.parameters
+        if self.parent_path is not None: body['parent_path'] = self.parent_path
+        if self.query_text is not None: body['query_text'] = self.query_text
+        if self.run_as_mode is not None: body['run_as_mode'] = self.run_as_mode
+        if self.schema is not None: body['schema'] = self.schema
+        if self.tags: body['tags'] = self.tags
+        if self.update_time is not None: body['update_time'] = self.update_time
+        if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> Query:
         """Deserializes the Query from a dictionary."""
@@ -3273,6 +4000,14 @@ class QueryBackedValue:
         if self.values: body['values'] = [v for v in self.values]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the QueryBackedValue into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.multi_values_options: body['multi_values_options'] = self.multi_values_options
+        if self.query_id is not None: body['query_id'] = self.query_id
+        if self.values: body['values'] = self.values
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> QueryBackedValue:
         """Deserializes the QueryBackedValue from a dictionary."""
@@ -3324,6 +4059,19 @@ class QueryEditContent:
         if self.tags: body['tags'] = [v for v in self.tags]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the QueryEditContent into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.data_source_id is not None: body['data_source_id'] = self.data_source_id
+        if self.description is not None: body['description'] = self.description
+        if self.name is not None: body['name'] = self.name
+        if self.options: body['options'] = self.options
+        if self.query is not None: body['query'] = self.query
+        if self.query_id is not None: body['query_id'] = self.query_id
+        if self.run_as_role is not None: body['run_as_role'] = self.run_as_role
+        if self.tags: body['tags'] = self.tags
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> QueryEditContent:
         """Deserializes the QueryEditContent from a dictionary."""
@@ -3363,6 +4111,16 @@ class QueryFilter:
         if self.warehouse_ids: body['warehouse_ids'] = [v for v in self.warehouse_ids]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the QueryFilter into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.query_start_time_range: body['query_start_time_range'] = self.query_start_time_range
+        if self.statement_ids: body['statement_ids'] = self.statement_ids
+        if self.statuses: body['statuses'] = self.statuses
+        if self.user_ids: body['user_ids'] = self.user_ids
+        if self.warehouse_ids: body['warehouse_ids'] = self.warehouse_ids
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> QueryFilter:
         """Deserializes the QueryFilter from a dictionary."""
@@ -3472,6 +4230,33 @@ class QueryInfo:
         if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the QueryInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.channel_used: body['channel_used'] = self.channel_used
+        if self.duration is not None: body['duration'] = self.duration
+        if self.endpoint_id is not None: body['endpoint_id'] = self.endpoint_id
+        if self.error_message is not None: body['error_message'] = self.error_message
+        if self.executed_as_user_id is not None: body['executed_as_user_id'] = self.executed_as_user_id
+        if self.executed_as_user_name is not None: body['executed_as_user_name'] = self.executed_as_user_name
+        if self.execution_end_time_ms is not None: body['execution_end_time_ms'] = self.execution_end_time_ms
+        if self.is_final is not None: body['is_final'] = self.is_final
+        if self.lookup_key is not None: body['lookup_key'] = self.lookup_key
+        if self.metrics: body['metrics'] = self.metrics
+        if self.plans_state is not None: body['plans_state'] = self.plans_state
+        if self.query_end_time_ms is not None: body['query_end_time_ms'] = self.query_end_time_ms
+        if self.query_id is not None: body['query_id'] = self.query_id
+        if self.query_start_time_ms is not None: body['query_start_time_ms'] = self.query_start_time_ms
+        if self.query_text is not None: body['query_text'] = self.query_text
+        if self.rows_produced is not None: body['rows_produced'] = self.rows_produced
+        if self.spark_ui_url is not None: body['spark_ui_url'] = self.spark_ui_url
+        if self.statement_type is not None: body['statement_type'] = self.statement_type
+        if self.status is not None: body['status'] = self.status
+        if self.user_id is not None: body['user_id'] = self.user_id
+        if self.user_name is not None: body['user_name'] = self.user_name
+        if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> QueryInfo:
         """Deserializes the QueryInfo from a dictionary."""
@@ -3522,6 +4307,15 @@ class QueryList:
         if self.results: body['results'] = [v.as_dict() for v in self.results]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the QueryList into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.count is not None: body['count'] = self.count
+        if self.page is not None: body['page'] = self.page
+        if self.page_size is not None: body['page_size'] = self.page_size
+        if self.results: body['results'] = self.results
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> QueryList:
         """Deserializes the QueryList from a dictionary."""
@@ -3605,8 +4399,38 @@ class QueryMetrics:
     write_remote_bytes: Optional[int] = None
     """Size pf persistent data written to cloud object storage in your cloud tenant, in bytes."""
 
-    def as_dict(self) -> dict:
-        """Serializes the QueryMetrics into a dictionary suitable for use as a JSON request body."""
+    def as_dict(self) -> dict:
+        """Serializes the QueryMetrics into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.compilation_time_ms is not None: body['compilation_time_ms'] = self.compilation_time_ms
+        if self.execution_time_ms is not None: body['execution_time_ms'] = self.execution_time_ms
+        if self.network_sent_bytes is not None: body['network_sent_bytes'] = self.network_sent_bytes
+        if self.overloading_queue_start_timestamp is not None:
+            body['overloading_queue_start_timestamp'] = self.overloading_queue_start_timestamp
+        if self.photon_total_time_ms is not None: body['photon_total_time_ms'] = self.photon_total_time_ms
+        if self.provisioning_queue_start_timestamp is not None:
+            body['provisioning_queue_start_timestamp'] = self.provisioning_queue_start_timestamp
+        if self.pruned_bytes is not None: body['pruned_bytes'] = self.pruned_bytes
+        if self.pruned_files_count is not None: body['pruned_files_count'] = self.pruned_files_count
+        if self.query_compilation_start_timestamp is not None:
+            body['query_compilation_start_timestamp'] = self.query_compilation_start_timestamp
+        if self.read_bytes is not None: body['read_bytes'] = self.read_bytes
+        if self.read_cache_bytes is not None: body['read_cache_bytes'] = self.read_cache_bytes
+        if self.read_files_count is not None: body['read_files_count'] = self.read_files_count
+        if self.read_partitions_count is not None: body['read_partitions_count'] = self.read_partitions_count
+        if self.read_remote_bytes is not None: body['read_remote_bytes'] = self.read_remote_bytes
+        if self.result_fetch_time_ms is not None: body['result_fetch_time_ms'] = self.result_fetch_time_ms
+        if self.result_from_cache is not None: body['result_from_cache'] = self.result_from_cache
+        if self.rows_produced_count is not None: body['rows_produced_count'] = self.rows_produced_count
+        if self.rows_read_count is not None: body['rows_read_count'] = self.rows_read_count
+        if self.spill_to_disk_bytes is not None: body['spill_to_disk_bytes'] = self.spill_to_disk_bytes
+        if self.task_total_time_ms is not None: body['task_total_time_ms'] = self.task_total_time_ms
+        if self.total_time_ms is not None: body['total_time_ms'] = self.total_time_ms
+        if self.write_remote_bytes is not None: body['write_remote_bytes'] = self.write_remote_bytes
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the QueryMetrics into a shallow dictionary of its immediate attributes."""
         body = {}
         if self.compilation_time_ms is not None: body['compilation_time_ms'] = self.compilation_time_ms
         if self.execution_time_ms is not None: body['execution_time_ms'] = self.execution_time_ms
@@ -3685,6 +4509,15 @@ class QueryOptions:
         if self.schema is not None: body['schema'] = self.schema
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the QueryOptions into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.catalog is not None: body['catalog'] = self.catalog
+        if self.moved_to_trash_at is not None: body['moved_to_trash_at'] = self.moved_to_trash_at
+        if self.parameters: body['parameters'] = self.parameters
+        if self.schema is not None: body['schema'] = self.schema
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> QueryOptions:
         """Deserializes the QueryOptions from a dictionary."""
@@ -3734,6 +4567,19 @@ class QueryParameter:
         if self.title is not None: body['title'] = self.title
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the QueryParameter into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.date_range_value: body['date_range_value'] = self.date_range_value
+        if self.date_value: body['date_value'] = self.date_value
+        if self.enum_value: body['enum_value'] = self.enum_value
+        if self.name is not None: body['name'] = self.name
+        if self.numeric_value: body['numeric_value'] = self.numeric_value
+        if self.query_backed_value: body['query_backed_value'] = self.query_backed_value
+        if self.text_value: body['text_value'] = self.text_value
+        if self.title is not None: body['title'] = self.title
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> QueryParameter:
         """Deserializes the QueryParameter from a dictionary."""
@@ -3791,6 +4637,19 @@ class QueryPostContent:
         if self.tags: body['tags'] = [v for v in self.tags]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the QueryPostContent into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.data_source_id is not None: body['data_source_id'] = self.data_source_id
+        if self.description is not None: body['description'] = self.description
+        if self.name is not None: body['name'] = self.name
+        if self.options: body['options'] = self.options
+        if self.parent is not None: body['parent'] = self.parent
+        if self.query is not None: body['query'] = self.query
+        if self.run_as_role is not None: body['run_as_role'] = self.run_as_role
+        if self.tags: body['tags'] = self.tags
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> QueryPostContent:
         """Deserializes the QueryPostContent from a dictionary."""
@@ -3858,6 +4717,13 @@ class RepeatedEndpointConfPairs:
             body['configuration_pairs'] = [v.as_dict() for v in self.configuration_pairs]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the RepeatedEndpointConfPairs into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.config_pair: body['config_pair'] = self.config_pair
+        if self.configuration_pairs: body['configuration_pairs'] = self.configuration_pairs
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> RepeatedEndpointConfPairs:
         """Deserializes the RepeatedEndpointConfPairs from a dictionary."""
@@ -3873,6 +4739,11 @@ class RestoreResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the RestoreResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> RestoreResponse:
         """Deserializes the RestoreResponse from a dictionary."""
@@ -3924,6 +4795,20 @@ class ResultData:
         if self.row_offset is not None: body['row_offset'] = self.row_offset
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ResultData into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.byte_count is not None: body['byte_count'] = self.byte_count
+        if self.chunk_index is not None: body['chunk_index'] = self.chunk_index
+        if self.data_array: body['data_array'] = self.data_array
+        if self.external_links: body['external_links'] = self.external_links
+        if self.next_chunk_index is not None: body['next_chunk_index'] = self.next_chunk_index
+        if self.next_chunk_internal_link is not None:
+            body['next_chunk_internal_link'] = self.next_chunk_internal_link
+        if self.row_count is not None: body['row_count'] = self.row_count
+        if self.row_offset is not None: body['row_offset'] = self.row_offset
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ResultData:
         """Deserializes the ResultData from a dictionary."""
@@ -3974,6 +4859,18 @@ class ResultManifest:
         if self.truncated is not None: body['truncated'] = self.truncated
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ResultManifest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.chunks: body['chunks'] = self.chunks
+        if self.format is not None: body['format'] = self.format
+        if self.schema: body['schema'] = self.schema
+        if self.total_byte_count is not None: body['total_byte_count'] = self.total_byte_count
+        if self.total_chunk_count is not None: body['total_chunk_count'] = self.total_chunk_count
+        if self.total_row_count is not None: body['total_row_count'] = self.total_row_count
+        if self.truncated is not None: body['truncated'] = self.truncated
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ResultManifest:
         """Deserializes the ResultManifest from a dictionary."""
@@ -4001,6 +4898,13 @@ class ResultSchema:
         if self.columns: body['columns'] = [v.as_dict() for v in self.columns]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ResultSchema into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.column_count is not None: body['column_count'] = self.column_count
+        if self.columns: body['columns'] = self.columns
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ResultSchema:
         """Deserializes the ResultSchema from a dictionary."""
@@ -4035,6 +4939,13 @@ class ServiceError:
         if self.message is not None: body['message'] = self.message
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ServiceError into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.error_code is not None: body['error_code'] = self.error_code
+        if self.message is not None: body['message'] = self.message
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ServiceError:
         """Deserializes the ServiceError from a dictionary."""
@@ -4078,6 +4989,14 @@ class SetResponse:
         if self.object_type is not None: body['object_type'] = self.object_type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the SetResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.access_control_list: body['access_control_list'] = self.access_control_list
+        if self.object_id is not None: body['object_id'] = self.object_id
+        if self.object_type is not None: body['object_type'] = self.object_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> SetResponse:
         """Deserializes the SetResponse from a dictionary."""
@@ -4138,6 +5057,22 @@ class SetWorkspaceWarehouseConfigRequest:
             body['sql_configuration_parameters'] = self.sql_configuration_parameters.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the SetWorkspaceWarehouseConfigRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.channel: body['channel'] = self.channel
+        if self.config_param: body['config_param'] = self.config_param
+        if self.data_access_config: body['data_access_config'] = self.data_access_config
+        if self.enabled_warehouse_types: body['enabled_warehouse_types'] = self.enabled_warehouse_types
+        if self.global_param: body['global_param'] = self.global_param
+        if self.google_service_account is not None:
+            body['google_service_account'] = self.google_service_account
+        if self.instance_profile_arn is not None: body['instance_profile_arn'] = self.instance_profile_arn
+        if self.security_policy is not None: body['security_policy'] = self.security_policy
+        if self.sql_configuration_parameters:
+            body['sql_configuration_parameters'] = self.sql_configuration_parameters
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> SetWorkspaceWarehouseConfigRequest:
         """Deserializes the SetWorkspaceWarehouseConfigRequest from a dictionary."""
@@ -4170,6 +5105,11 @@ class SetWorkspaceWarehouseConfigResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the SetWorkspaceWarehouseConfigResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> SetWorkspaceWarehouseConfigResponse:
         """Deserializes the SetWorkspaceWarehouseConfigResponse from a dictionary."""
@@ -4192,6 +5132,11 @@ class StartWarehouseResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the StartWarehouseResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> StartWarehouseResponse:
         """Deserializes the StartWarehouseResponse from a dictionary."""
@@ -4233,6 +5178,14 @@ class StatementParameterListItem:
         if self.value is not None: body['value'] = self.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the StatementParameterListItem into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.name is not None: body['name'] = self.name
+        if self.type is not None: body['type'] = self.type
+        if self.value is not None: body['value'] = self.value
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> StatementParameterListItem:
         """Deserializes the StatementParameterListItem from a dictionary."""
@@ -4262,6 +5215,15 @@ class StatementResponse:
         if self.status: body['status'] = self.status.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the StatementResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.manifest: body['manifest'] = self.manifest
+        if self.result: body['result'] = self.result
+        if self.statement_id is not None: body['statement_id'] = self.statement_id
+        if self.status: body['status'] = self.status
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> StatementResponse:
         """Deserializes the StatementResponse from a dictionary."""
@@ -4306,6 +5268,13 @@ class StatementStatus:
         if self.state is not None: body['state'] = self.state.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the StatementStatus into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.error: body['error'] = self.error
+        if self.state is not None: body['state'] = self.state
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> StatementStatus:
         """Deserializes the StatementStatus from a dictionary."""
@@ -4329,6 +5298,11 @@ class StopWarehouseResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the StopWarehouseResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> StopWarehouseResponse:
         """Deserializes the StopWarehouseResponse from a dictionary."""
@@ -4345,6 +5319,12 @@ class Success:
         if self.message is not None: body['message'] = self.message.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Success into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.message is not None: body['message'] = self.message
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> Success:
         """Deserializes the Success from a dictionary."""
@@ -4375,6 +5355,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."""
@@ -4486,6 +5474,12 @@ class TextValue:
         if self.value is not None: body['value'] = self.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the TextValue into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.value is not None: body['value'] = self.value
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> TextValue:
         """Deserializes the TextValue from a dictionary."""
@@ -4507,6 +5501,13 @@ class TimeRange:
         if self.start_time_ms is not None: body['start_time_ms'] = self.start_time_ms
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the TimeRange into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.end_time_ms is not None: body['end_time_ms'] = self.end_time_ms
+        if self.start_time_ms is not None: body['start_time_ms'] = self.start_time_ms
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> TimeRange:
         """Deserializes the TimeRange from a dictionary."""
@@ -4524,6 +5525,12 @@ class TransferOwnershipObjectId:
         if self.new_owner is not None: body['new_owner'] = self.new_owner
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the TransferOwnershipObjectId into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.new_owner is not None: body['new_owner'] = self.new_owner
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> TransferOwnershipObjectId:
         """Deserializes the TransferOwnershipObjectId from a dictionary."""
@@ -4549,6 +5556,14 @@ class UpdateAlertRequest:
         if self.update_mask is not None: body['update_mask'] = self.update_mask
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateAlertRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.alert: body['alert'] = self.alert
+        if self.id is not None: body['id'] = self.id
+        if self.update_mask is not None: body['update_mask'] = self.update_mask
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateAlertRequest:
         """Deserializes the UpdateAlertRequest from a dictionary."""
@@ -4602,6 +5617,19 @@ class UpdateAlertRequestAlert:
         if self.seconds_to_retrigger is not None: body['seconds_to_retrigger'] = self.seconds_to_retrigger
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateAlertRequestAlert into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.condition: body['condition'] = self.condition
+        if self.custom_body is not None: body['custom_body'] = self.custom_body
+        if self.custom_subject is not None: body['custom_subject'] = self.custom_subject
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.notify_on_ok is not None: body['notify_on_ok'] = self.notify_on_ok
+        if self.owner_user_name is not None: body['owner_user_name'] = self.owner_user_name
+        if self.query_id is not None: body['query_id'] = self.query_id
+        if self.seconds_to_retrigger is not None: body['seconds_to_retrigger'] = self.seconds_to_retrigger
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateAlertRequestAlert:
         """Deserializes the UpdateAlertRequestAlert from a dictionary."""
@@ -4634,6 +5662,14 @@ class UpdateQueryRequest:
         if self.update_mask is not None: body['update_mask'] = self.update_mask
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateQueryRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.id is not None: body['id'] = self.id
+        if self.query: body['query'] = self.query
+        if self.update_mask is not None: body['update_mask'] = self.update_mask
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateQueryRequest:
         """Deserializes the UpdateQueryRequest from a dictionary."""
@@ -4692,6 +5728,22 @@ class UpdateQueryRequestQuery:
         if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateQueryRequestQuery into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.apply_auto_limit is not None: body['apply_auto_limit'] = self.apply_auto_limit
+        if self.catalog is not None: body['catalog'] = self.catalog
+        if self.description is not None: body['description'] = self.description
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.owner_user_name is not None: body['owner_user_name'] = self.owner_user_name
+        if self.parameters: body['parameters'] = self.parameters
+        if self.query_text is not None: body['query_text'] = self.query_text
+        if self.run_as_mode is not None: body['run_as_mode'] = self.run_as_mode
+        if self.schema is not None: body['schema'] = self.schema
+        if self.tags: body['tags'] = self.tags
+        if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateQueryRequestQuery:
         """Deserializes the UpdateQueryRequestQuery from a dictionary."""
@@ -4716,6 +5768,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."""
@@ -4741,6 +5798,14 @@ class UpdateVisualizationRequest:
         if self.visualization: body['visualization'] = self.visualization.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateVisualizationRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.id is not None: body['id'] = self.id
+        if self.update_mask is not None: body['update_mask'] = self.update_mask
+        if self.visualization: body['visualization'] = self.visualization
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateVisualizationRequest:
         """Deserializes the UpdateVisualizationRequest from a dictionary."""
@@ -4774,6 +5839,15 @@ class UpdateVisualizationRequestVisualization:
         if self.type is not None: body['type'] = self.type
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateVisualizationRequestVisualization into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.serialized_options is not None: body['serialized_options'] = self.serialized_options
+        if self.serialized_query_plan is not None: body['serialized_query_plan'] = self.serialized_query_plan
+        if self.type is not None: body['type'] = self.type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateVisualizationRequestVisualization:
         """Deserializes the UpdateVisualizationRequestVisualization from a dictionary."""
@@ -4799,6 +5873,14 @@ class User:
         if self.name is not None: body['name'] = self.name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the User into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.email is not None: body['email'] = self.email
+        if self.id is not None: body['id'] = self.id
+        if self.name is not None: body['name'] = self.name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> User:
         """Deserializes the User from a dictionary."""
@@ -4846,6 +5928,19 @@ class Visualization:
         if self.update_time is not None: body['update_time'] = self.update_time
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Visualization into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.create_time is not None: body['create_time'] = self.create_time
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.id is not None: body['id'] = self.id
+        if self.query_id is not None: body['query_id'] = self.query_id
+        if self.serialized_options is not None: body['serialized_options'] = self.serialized_options
+        if self.serialized_query_plan is not None: body['serialized_query_plan'] = self.serialized_query_plan
+        if self.type is not None: body['type'] = self.type
+        if self.update_time is not None: body['update_time'] = self.update_time
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> Visualization:
         """Deserializes the Visualization from a dictionary."""
@@ -4883,6 +5978,16 @@ class WarehouseAccessControlRequest:
         if self.user_name is not None: body['user_name'] = self.user_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the WarehouseAccessControlRequest 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]) -> WarehouseAccessControlRequest:
         """Deserializes the WarehouseAccessControlRequest from a dictionary."""
@@ -4920,6 +6025,17 @@ class WarehouseAccessControlResponse:
         if self.user_name is not None: body['user_name'] = self.user_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the WarehouseAccessControlResponse 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]) -> WarehouseAccessControlResponse:
         """Deserializes the WarehouseAccessControlResponse from a dictionary."""
@@ -4947,6 +6063,14 @@ class WarehousePermission:
         if self.permission_level is not None: body['permission_level'] = self.permission_level.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the WarehousePermission 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]) -> WarehousePermission:
         """Deserializes the WarehousePermission from a dictionary."""
@@ -4981,6 +6105,14 @@ class WarehousePermissions:
         if self.object_type is not None: body['object_type'] = self.object_type
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the WarehousePermissions 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]) -> WarehousePermissions:
         """Deserializes the WarehousePermissions from a dictionary."""
@@ -5004,6 +6136,13 @@ class WarehousePermissionsDescription:
         if self.permission_level is not None: body['permission_level'] = self.permission_level.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the WarehousePermissionsDescription 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]) -> WarehousePermissionsDescription:
         """Deserializes the WarehousePermissionsDescription from a dictionary."""
@@ -5026,6 +6165,13 @@ class WarehousePermissionsRequest:
         if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the WarehousePermissionsRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.access_control_list: body['access_control_list'] = self.access_control_list
+        if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> WarehousePermissionsRequest:
         """Deserializes the WarehousePermissionsRequest from a dictionary."""
@@ -5050,6 +6196,13 @@ class WarehouseTypePair:
         if self.warehouse_type is not None: body['warehouse_type'] = self.warehouse_type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the WarehouseTypePair into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.enabled is not None: body['enabled'] = self.enabled
+        if self.warehouse_type is not None: body['warehouse_type'] = self.warehouse_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> WarehouseTypePair:
         """Deserializes the WarehouseTypePair from a dictionary."""
@@ -5090,6 +6243,15 @@ class Widget:
         if self.width is not None: body['width'] = self.width
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Widget into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.id is not None: body['id'] = self.id
+        if self.options: body['options'] = self.options
+        if self.visualization: body['visualization'] = self.visualization
+        if self.width is not None: body['width'] = self.width
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> Widget:
         """Deserializes the Widget from a dictionary."""
@@ -5136,6 +6298,18 @@ class WidgetOptions:
         if self.updated_at is not None: body['updated_at'] = self.updated_at
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the WidgetOptions into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.description is not None: body['description'] = self.description
+        if self.is_hidden is not None: body['isHidden'] = self.is_hidden
+        if self.parameter_mappings: body['parameterMappings'] = self.parameter_mappings
+        if self.position: body['position'] = self.position
+        if self.title is not None: body['title'] = self.title
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> WidgetOptions:
         """Deserializes the WidgetOptions from a dictionary."""
@@ -5178,6 +6352,16 @@ class WidgetPosition:
         if self.size_y is not None: body['sizeY'] = self.size_y
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the WidgetPosition into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.auto_height is not None: body['autoHeight'] = self.auto_height
+        if self.col is not None: body['col'] = self.col
+        if self.row is not None: body['row'] = self.row
+        if self.size_x is not None: body['sizeX'] = self.size_x
+        if self.size_y is not None: body['sizeY'] = self.size_y
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> WidgetPosition:
         """Deserializes the WidgetPosition from a dictionary."""