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

databricks/sdk/service/settings.py

@@ -24,6 +24,12 @@ class AibiDashboardEmbeddingAccessPolicy:
         if self.access_policy_type is not None: body['access_policy_type'] = self.access_policy_type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AibiDashboardEmbeddingAccessPolicy into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.access_policy_type is not None: body['access_policy_type'] = self.access_policy_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AibiDashboardEmbeddingAccessPolicy:
         """Deserializes the AibiDashboardEmbeddingAccessPolicy from a dictionary."""
@@ -67,6 +73,15 @@ class AibiDashboardEmbeddingAccessPolicySetting:
         if self.setting_name is not None: body['setting_name'] = self.setting_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AibiDashboardEmbeddingAccessPolicySetting into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.aibi_dashboard_embedding_access_policy:
+            body['aibi_dashboard_embedding_access_policy'] = self.aibi_dashboard_embedding_access_policy
+        if self.etag is not None: body['etag'] = self.etag
+        if self.setting_name is not None: body['setting_name'] = self.setting_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AibiDashboardEmbeddingAccessPolicySetting:
         """Deserializes the AibiDashboardEmbeddingAccessPolicySetting from a dictionary."""
@@ -86,6 +101,12 @@ class AibiDashboardEmbeddingApprovedDomains:
         if self.approved_domains: body['approved_domains'] = [v for v in self.approved_domains]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AibiDashboardEmbeddingApprovedDomains into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.approved_domains: body['approved_domains'] = self.approved_domains
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AibiDashboardEmbeddingApprovedDomains:
         """Deserializes the AibiDashboardEmbeddingApprovedDomains from a dictionary."""
@@ -121,6 +142,15 @@ class AibiDashboardEmbeddingApprovedDomainsSetting:
         if self.setting_name is not None: body['setting_name'] = self.setting_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AibiDashboardEmbeddingApprovedDomainsSetting into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.aibi_dashboard_embedding_approved_domains:
+            body['aibi_dashboard_embedding_approved_domains'] = self.aibi_dashboard_embedding_approved_domains
+        if self.etag is not None: body['etag'] = self.etag
+        if self.setting_name is not None: body['setting_name'] = self.setting_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AibiDashboardEmbeddingApprovedDomainsSetting:
         """Deserializes the AibiDashboardEmbeddingApprovedDomainsSetting from a dictionary."""
@@ -157,6 +187,15 @@ class AutomaticClusterUpdateSetting:
         if self.setting_name is not None: body['setting_name'] = self.setting_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AutomaticClusterUpdateSetting into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.automatic_cluster_update_workspace:
+            body['automatic_cluster_update_workspace'] = self.automatic_cluster_update_workspace
+        if self.etag is not None: body['etag'] = self.etag
+        if self.setting_name is not None: body['setting_name'] = self.setting_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AutomaticClusterUpdateSetting:
         """Deserializes the AutomaticClusterUpdateSetting from a dictionary."""
@@ -176,6 +215,12 @@ class BooleanMessage:
         if self.value is not None: body['value'] = self.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the BooleanMessage 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]) -> BooleanMessage:
         """Deserializes the BooleanMessage from a dictionary."""
@@ -210,6 +255,17 @@ class ClusterAutoRestartMessage:
             body['restart_even_if_no_updates_available'] = self.restart_even_if_no_updates_available
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterAutoRestartMessage into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.can_toggle is not None: body['can_toggle'] = self.can_toggle
+        if self.enabled is not None: body['enabled'] = self.enabled
+        if self.enablement_details: body['enablement_details'] = self.enablement_details
+        if self.maintenance_window: body['maintenance_window'] = self.maintenance_window
+        if self.restart_even_if_no_updates_available is not None:
+            body['restart_even_if_no_updates_available'] = self.restart_even_if_no_updates_available
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterAutoRestartMessage:
         """Deserializes the ClusterAutoRestartMessage from a dictionary."""
@@ -251,6 +307,17 @@ class ClusterAutoRestartMessageEnablementDetails:
             body['unavailable_for_non_enterprise_tier'] = self.unavailable_for_non_enterprise_tier
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterAutoRestartMessageEnablementDetails into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.forced_for_compliance_mode is not None:
+            body['forced_for_compliance_mode'] = self.forced_for_compliance_mode
+        if self.unavailable_for_disabled_entitlement is not None:
+            body['unavailable_for_disabled_entitlement'] = self.unavailable_for_disabled_entitlement
+        if self.unavailable_for_non_enterprise_tier is not None:
+            body['unavailable_for_non_enterprise_tier'] = self.unavailable_for_non_enterprise_tier
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterAutoRestartMessageEnablementDetails:
         """Deserializes the ClusterAutoRestartMessageEnablementDetails from a dictionary."""
@@ -270,6 +337,12 @@ class ClusterAutoRestartMessageMaintenanceWindow:
             body['week_day_based_schedule'] = self.week_day_based_schedule.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterAutoRestartMessageMaintenanceWindow into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.week_day_based_schedule: body['week_day_based_schedule'] = self.week_day_based_schedule
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterAutoRestartMessageMaintenanceWindow:
         """Deserializes the ClusterAutoRestartMessageMaintenanceWindow from a dictionary."""
@@ -304,6 +377,14 @@ class ClusterAutoRestartMessageMaintenanceWindowWeekDayBasedSchedule:
         if self.window_start_time: body['window_start_time'] = self.window_start_time.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterAutoRestartMessageMaintenanceWindowWeekDayBasedSchedule into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.day_of_week is not None: body['day_of_week'] = self.day_of_week
+        if self.frequency is not None: body['frequency'] = self.frequency
+        if self.window_start_time: body['window_start_time'] = self.window_start_time
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterAutoRestartMessageMaintenanceWindowWeekDayBasedSchedule:
         """Deserializes the ClusterAutoRestartMessageMaintenanceWindowWeekDayBasedSchedule from a dictionary."""
@@ -338,6 +419,13 @@ class ClusterAutoRestartMessageMaintenanceWindowWindowStartTime:
         if self.minutes is not None: body['minutes'] = self.minutes
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ClusterAutoRestartMessageMaintenanceWindowWindowStartTime into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.hours is not None: body['hours'] = self.hours
+        if self.minutes is not None: body['minutes'] = self.minutes
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ClusterAutoRestartMessageMaintenanceWindowWindowStartTime:
         """Deserializes the ClusterAutoRestartMessageMaintenanceWindowWindowStartTime from a dictionary."""
@@ -361,6 +449,13 @@ class ComplianceSecurityProfile:
         if self.is_enabled is not None: body['is_enabled'] = self.is_enabled
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ComplianceSecurityProfile into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.compliance_standards: body['compliance_standards'] = self.compliance_standards
+        if self.is_enabled is not None: body['is_enabled'] = self.is_enabled
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ComplianceSecurityProfile:
         """Deserializes the ComplianceSecurityProfile from a dictionary."""
@@ -398,6 +493,15 @@ class ComplianceSecurityProfileSetting:
         if self.setting_name is not None: body['setting_name'] = self.setting_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ComplianceSecurityProfileSetting into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.compliance_security_profile_workspace:
+            body['compliance_security_profile_workspace'] = self.compliance_security_profile_workspace
+        if self.etag is not None: body['etag'] = self.etag
+        if self.setting_name is not None: body['setting_name'] = self.setting_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ComplianceSecurityProfileSetting:
         """Deserializes the ComplianceSecurityProfileSetting from a dictionary."""
@@ -445,6 +549,16 @@ class Config:
         if self.slack: body['slack'] = self.slack.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Config into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.email: body['email'] = self.email
+        if self.generic_webhook: body['generic_webhook'] = self.generic_webhook
+        if self.microsoft_teams: body['microsoft_teams'] = self.microsoft_teams
+        if self.pagerduty: body['pagerduty'] = self.pagerduty
+        if self.slack: body['slack'] = self.slack
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> Config:
         """Deserializes the Config from a dictionary."""
@@ -478,6 +592,14 @@ class CreateIpAccessList:
         if self.list_type is not None: body['list_type'] = self.list_type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateIpAccessList into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.ip_addresses: body['ip_addresses'] = self.ip_addresses
+        if self.label is not None: body['label'] = self.label
+        if self.list_type is not None: body['list_type'] = self.list_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateIpAccessList:
         """Deserializes the CreateIpAccessList from a dictionary."""
@@ -499,6 +621,12 @@ class CreateIpAccessListResponse:
         if self.ip_access_list: body['ip_access_list'] = self.ip_access_list.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateIpAccessListResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.ip_access_list: body['ip_access_list'] = self.ip_access_list
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateIpAccessListResponse:
         """Deserializes the CreateIpAccessListResponse from a dictionary."""
@@ -523,6 +651,13 @@ class CreateNetworkConnectivityConfigRequest:
         if self.region is not None: body['region'] = self.region
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateNetworkConnectivityConfigRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.name is not None: body['name'] = self.name
+        if self.region is not None: body['region'] = self.region
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateNetworkConnectivityConfigRequest:
         """Deserializes the CreateNetworkConnectivityConfigRequest from a dictionary."""
@@ -544,6 +679,13 @@ class CreateNotificationDestinationRequest:
         if self.display_name is not None: body['display_name'] = self.display_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateNotificationDestinationRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.config: body['config'] = self.config
+        if self.display_name is not None: body['display_name'] = self.display_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateNotificationDestinationRequest:
         """Deserializes the CreateNotificationDestinationRequest from a dictionary."""
@@ -571,6 +713,14 @@ class CreateOboTokenRequest:
         if self.lifetime_seconds is not None: body['lifetime_seconds'] = self.lifetime_seconds
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateOboTokenRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.application_id is not None: body['application_id'] = self.application_id
+        if self.comment is not None: body['comment'] = self.comment
+        if self.lifetime_seconds is not None: body['lifetime_seconds'] = self.lifetime_seconds
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateOboTokenRequest:
         """Deserializes the CreateOboTokenRequest from a dictionary."""
@@ -595,6 +745,13 @@ class CreateOboTokenResponse:
         if self.token_value is not None: body['token_value'] = self.token_value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateOboTokenResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.token_info: body['token_info'] = self.token_info
+        if self.token_value is not None: body['token_value'] = self.token_value
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateOboTokenResponse:
         """Deserializes the CreateOboTokenResponse from a dictionary."""
@@ -622,6 +779,15 @@ class CreatePrivateEndpointRuleRequest:
         if self.resource_id is not None: body['resource_id'] = self.resource_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreatePrivateEndpointRuleRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.group_id is not None: body['group_id'] = self.group_id
+        if self.network_connectivity_config_id is not None:
+            body['network_connectivity_config_id'] = self.network_connectivity_config_id
+        if self.resource_id is not None: body['resource_id'] = self.resource_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreatePrivateEndpointRuleRequest:
         """Deserializes the CreatePrivateEndpointRuleRequest from a dictionary."""
@@ -657,6 +823,13 @@ class CreateTokenRequest:
         if self.lifetime_seconds is not None: body['lifetime_seconds'] = self.lifetime_seconds
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateTokenRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.comment is not None: body['comment'] = self.comment
+        if self.lifetime_seconds is not None: body['lifetime_seconds'] = self.lifetime_seconds
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateTokenRequest:
         """Deserializes the CreateTokenRequest from a dictionary."""
@@ -678,6 +851,13 @@ class CreateTokenResponse:
         if self.token_value is not None: body['token_value'] = self.token_value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateTokenResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.token_info: body['token_info'] = self.token_info
+        if self.token_value is not None: body['token_value'] = self.token_value
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateTokenResponse:
         """Deserializes the CreateTokenResponse from a dictionary."""
@@ -704,6 +884,13 @@ class CspEnablementAccount:
         if self.is_enforced is not None: body['is_enforced'] = self.is_enforced
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CspEnablementAccount into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.compliance_standards: body['compliance_standards'] = self.compliance_standards
+        if self.is_enforced is not None: body['is_enforced'] = self.is_enforced
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CspEnablementAccount:
         """Deserializes the CspEnablementAccount from a dictionary."""
@@ -738,6 +925,14 @@ class CspEnablementAccountSetting:
         if self.setting_name is not None: body['setting_name'] = self.setting_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CspEnablementAccountSetting into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.csp_enablement_account: body['csp_enablement_account'] = self.csp_enablement_account
+        if self.etag is not None: body['etag'] = self.etag
+        if self.setting_name is not None: body['setting_name'] = self.setting_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CspEnablementAccountSetting:
         """Deserializes the CspEnablementAccountSetting from a dictionary."""
@@ -780,6 +975,14 @@ class DefaultNamespaceSetting:
         if self.setting_name is not None: body['setting_name'] = self.setting_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DefaultNamespaceSetting into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.etag is not None: body['etag'] = self.etag
+        if self.namespace: body['namespace'] = self.namespace
+        if self.setting_name is not None: body['setting_name'] = self.setting_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DefaultNamespaceSetting:
         """Deserializes the DefaultNamespaceSetting from a dictionary."""
@@ -788,6 +991,66 @@ class DefaultNamespaceSetting:
                    setting_name=d.get('setting_name', None))
 
 
+@dataclass
+class DeleteAibiDashboardEmbeddingAccessPolicySettingResponse:
+    """The etag is returned."""
+
+    etag: str
+    """etag used for versioning. The response is at least as fresh as the eTag provided. This is used
+    for optimistic concurrency control as a way to help prevent simultaneous writes of a setting
+    overwriting each other. It is strongly suggested that systems make use of the etag in the read
+    -> delete pattern to perform setting deletions in order to avoid race conditions. That is, get
+    an etag from a GET request, and pass it with the DELETE request to identify the rule set version
+    you are deleting."""
+
+    def as_dict(self) -> dict:
+        """Serializes the DeleteAibiDashboardEmbeddingAccessPolicySettingResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.etag is not None: body['etag'] = self.etag
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeleteAibiDashboardEmbeddingAccessPolicySettingResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.etag is not None: body['etag'] = self.etag
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> DeleteAibiDashboardEmbeddingAccessPolicySettingResponse:
+        """Deserializes the DeleteAibiDashboardEmbeddingAccessPolicySettingResponse from a dictionary."""
+        return cls(etag=d.get('etag', None))
+
+
+@dataclass
+class DeleteAibiDashboardEmbeddingApprovedDomainsSettingResponse:
+    """The etag is returned."""
+
+    etag: str
+    """etag used for versioning. The response is at least as fresh as the eTag provided. This is used
+    for optimistic concurrency control as a way to help prevent simultaneous writes of a setting
+    overwriting each other. It is strongly suggested that systems make use of the etag in the read
+    -> delete pattern to perform setting deletions in order to avoid race conditions. That is, get
+    an etag from a GET request, and pass it with the DELETE request to identify the rule set version
+    you are deleting."""
+
+    def as_dict(self) -> dict:
+        """Serializes the DeleteAibiDashboardEmbeddingApprovedDomainsSettingResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.etag is not None: body['etag'] = self.etag
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeleteAibiDashboardEmbeddingApprovedDomainsSettingResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.etag is not None: body['etag'] = self.etag
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> DeleteAibiDashboardEmbeddingApprovedDomainsSettingResponse:
+        """Deserializes the DeleteAibiDashboardEmbeddingApprovedDomainsSettingResponse from a dictionary."""
+        return cls(etag=d.get('etag', None))
+
+
 @dataclass
 class DeleteDefaultNamespaceSettingResponse:
     """The etag is returned."""
@@ -806,6 +1069,12 @@ class DeleteDefaultNamespaceSettingResponse:
         if self.etag is not None: body['etag'] = self.etag
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeleteDefaultNamespaceSettingResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.etag is not None: body['etag'] = self.etag
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DeleteDefaultNamespaceSettingResponse:
         """Deserializes the DeleteDefaultNamespaceSettingResponse from a dictionary."""
@@ -830,6 +1099,12 @@ class DeleteDisableLegacyAccessResponse:
         if self.etag is not None: body['etag'] = self.etag
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeleteDisableLegacyAccessResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.etag is not None: body['etag'] = self.etag
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DeleteDisableLegacyAccessResponse:
         """Deserializes the DeleteDisableLegacyAccessResponse from a dictionary."""
@@ -854,6 +1129,12 @@ class DeleteDisableLegacyDbfsResponse:
         if self.etag is not None: body['etag'] = self.etag
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeleteDisableLegacyDbfsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.etag is not None: body['etag'] = self.etag
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DeleteDisableLegacyDbfsResponse:
         """Deserializes the DeleteDisableLegacyDbfsResponse from a dictionary."""
@@ -878,6 +1159,12 @@ class DeleteDisableLegacyFeaturesResponse:
         if self.etag is not None: body['etag'] = self.etag
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeleteDisableLegacyFeaturesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.etag is not None: body['etag'] = self.etag
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DeleteDisableLegacyFeaturesResponse:
         """Deserializes the DeleteDisableLegacyFeaturesResponse from a dictionary."""
@@ -892,6 +1179,11 @@ class DeleteNetworkConnectivityConfigurationResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeleteNetworkConnectivityConfigurationResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DeleteNetworkConnectivityConfigurationResponse:
         """Deserializes the DeleteNetworkConnectivityConfigurationResponse from a dictionary."""
@@ -916,6 +1208,12 @@ class DeletePersonalComputeSettingResponse:
         if self.etag is not None: body['etag'] = self.etag
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeletePersonalComputeSettingResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.etag is not None: body['etag'] = self.etag
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DeletePersonalComputeSettingResponse:
         """Deserializes the DeletePersonalComputeSettingResponse from a dictionary."""
@@ -930,6 +1228,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."""
@@ -954,6 +1257,12 @@ class DeleteRestrictWorkspaceAdminsSettingResponse:
         if self.etag is not None: body['etag'] = self.etag
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeleteRestrictWorkspaceAdminsSettingResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.etag is not None: body['etag'] = self.etag
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DeleteRestrictWorkspaceAdminsSettingResponse:
         """Deserializes the DeleteRestrictWorkspaceAdminsSettingResponse from a dictionary."""
@@ -995,6 +1304,14 @@ class DisableLegacyAccess:
         if self.setting_name is not None: body['setting_name'] = self.setting_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DisableLegacyAccess into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.disable_legacy_access: body['disable_legacy_access'] = self.disable_legacy_access
+        if self.etag is not None: body['etag'] = self.etag
+        if self.setting_name is not None: body['setting_name'] = self.setting_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DisableLegacyAccess:
         """Deserializes the DisableLegacyAccess from a dictionary."""
@@ -1029,6 +1346,14 @@ class DisableLegacyDbfs:
         if self.setting_name is not None: body['setting_name'] = self.setting_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DisableLegacyDbfs into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.disable_legacy_dbfs: body['disable_legacy_dbfs'] = self.disable_legacy_dbfs
+        if self.etag is not None: body['etag'] = self.etag
+        if self.setting_name is not None: body['setting_name'] = self.setting_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DisableLegacyDbfs:
         """Deserializes the DisableLegacyDbfs from a dictionary."""
@@ -1064,6 +1389,14 @@ class DisableLegacyFeatures:
         if self.setting_name is not None: body['setting_name'] = self.setting_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DisableLegacyFeatures into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.disable_legacy_features: body['disable_legacy_features'] = self.disable_legacy_features
+        if self.etag is not None: body['etag'] = self.etag
+        if self.setting_name is not None: body['setting_name'] = self.setting_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DisableLegacyFeatures:
         """Deserializes the DisableLegacyFeatures from a dictionary."""
@@ -1072,6 +1405,270 @@ class DisableLegacyFeatures:
                    setting_name=d.get('setting_name', None))
 
 
+@dataclass
+class EgressNetworkPolicy:
+    """The network policies applying for egress traffic. This message is used by the UI/REST API. We
+    translate this message to the format expected by the dataplane in Lakehouse Network Manager (for
+    the format expected by the dataplane, see networkconfig.textproto)."""
+
+    internet_access: Optional[EgressNetworkPolicyInternetAccessPolicy] = None
+    """The access policy enforced for egress traffic to the internet."""
+
+    def as_dict(self) -> dict:
+        """Serializes the EgressNetworkPolicy into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.internet_access: body['internet_access'] = self.internet_access.as_dict()
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EgressNetworkPolicy into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.internet_access: body['internet_access'] = self.internet_access
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> EgressNetworkPolicy:
+        """Deserializes the EgressNetworkPolicy from a dictionary."""
+        return cls(internet_access=_from_dict(d, 'internet_access', EgressNetworkPolicyInternetAccessPolicy))
+
+
+@dataclass
+class EgressNetworkPolicyInternetAccessPolicy:
+    allowed_internet_destinations: Optional[
+        List[EgressNetworkPolicyInternetAccessPolicyInternetDestination]] = None
+
+    allowed_storage_destinations: Optional[
+        List[EgressNetworkPolicyInternetAccessPolicyStorageDestination]] = None
+
+    log_only_mode: Optional[EgressNetworkPolicyInternetAccessPolicyLogOnlyMode] = None
+    """Optional. If not specified, assume the policy is enforced for all workloads."""
+
+    restriction_mode: Optional[EgressNetworkPolicyInternetAccessPolicyRestrictionMode] = None
+    """At which level can Databricks and Databricks managed compute access Internet. FULL_ACCESS:
+    Databricks can access Internet. No blocking rules will apply. RESTRICTED_ACCESS: Databricks can
+    only access explicitly allowed internet and storage destinations, as well as UC connections and
+    external locations. PRIVATE_ACCESS_ONLY (not used): Databricks can only access destinations via
+    private link."""
+
+    def as_dict(self) -> dict:
+        """Serializes the EgressNetworkPolicyInternetAccessPolicy into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.allowed_internet_destinations:
+            body['allowed_internet_destinations'] = [v.as_dict() for v in self.allowed_internet_destinations]
+        if self.allowed_storage_destinations:
+            body['allowed_storage_destinations'] = [v.as_dict() for v in self.allowed_storage_destinations]
+        if self.log_only_mode: body['log_only_mode'] = self.log_only_mode.as_dict()
+        if self.restriction_mode is not None: body['restriction_mode'] = self.restriction_mode.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EgressNetworkPolicyInternetAccessPolicy into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.allowed_internet_destinations:
+            body['allowed_internet_destinations'] = self.allowed_internet_destinations
+        if self.allowed_storage_destinations:
+            body['allowed_storage_destinations'] = self.allowed_storage_destinations
+        if self.log_only_mode: body['log_only_mode'] = self.log_only_mode
+        if self.restriction_mode is not None: body['restriction_mode'] = self.restriction_mode
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> EgressNetworkPolicyInternetAccessPolicy:
+        """Deserializes the EgressNetworkPolicyInternetAccessPolicy from a dictionary."""
+        return cls(allowed_internet_destinations=_repeated_dict(
+            d, 'allowed_internet_destinations', EgressNetworkPolicyInternetAccessPolicyInternetDestination),
+                   allowed_storage_destinations=_repeated_dict(
+                       d, 'allowed_storage_destinations',
+                       EgressNetworkPolicyInternetAccessPolicyStorageDestination),
+                   log_only_mode=_from_dict(d, 'log_only_mode',
+                                            EgressNetworkPolicyInternetAccessPolicyLogOnlyMode),
+                   restriction_mode=_enum(d, 'restriction_mode',
+                                          EgressNetworkPolicyInternetAccessPolicyRestrictionMode))
+
+
+@dataclass
+class EgressNetworkPolicyInternetAccessPolicyInternetDestination:
+    """Users can specify accessible internet destinations when outbound access is restricted. We only
+    support domain name (FQDN) destinations for the time being, though going forwards we want to
+    support host names and IP addresses."""
+
+    destination: Optional[str] = None
+
+    protocol: Optional[
+        EgressNetworkPolicyInternetAccessPolicyInternetDestinationInternetDestinationFilteringProtocol] = None
+    """The filtering protocol used by the DP. For private and public preview, SEG will only support TCP
+    filtering (i.e. DNS based filtering, filtering by destination IP address), so protocol will be
+    set to TCP by default and hidden from the user. In the future, users may be able to select HTTP
+    filtering (i.e. SNI based filtering, filtering by FQDN)."""
+
+    type: Optional[EgressNetworkPolicyInternetAccessPolicyInternetDestinationInternetDestinationType] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the EgressNetworkPolicyInternetAccessPolicyInternetDestination into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.destination is not None: body['destination'] = self.destination
+        if self.protocol is not None: body['protocol'] = self.protocol.value
+        if self.type is not None: body['type'] = self.type.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EgressNetworkPolicyInternetAccessPolicyInternetDestination into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.destination is not None: body['destination'] = self.destination
+        if self.protocol is not None: body['protocol'] = self.protocol
+        if self.type is not None: body['type'] = self.type
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> EgressNetworkPolicyInternetAccessPolicyInternetDestination:
+        """Deserializes the EgressNetworkPolicyInternetAccessPolicyInternetDestination from a dictionary."""
+        return cls(
+            destination=d.get('destination', None),
+            protocol=_enum(
+                d, 'protocol',
+                EgressNetworkPolicyInternetAccessPolicyInternetDestinationInternetDestinationFilteringProtocol
+            ),
+            type=_enum(d, 'type',
+                       EgressNetworkPolicyInternetAccessPolicyInternetDestinationInternetDestinationType))
+
+
+class EgressNetworkPolicyInternetAccessPolicyInternetDestinationInternetDestinationFilteringProtocol(Enum):
+    """The filtering protocol used by the DP. For private and public preview, SEG will only support TCP
+    filtering (i.e. DNS based filtering, filtering by destination IP address), so protocol will be
+    set to TCP by default and hidden from the user. In the future, users may be able to select HTTP
+    filtering (i.e. SNI based filtering, filtering by FQDN)."""
+
+    TCP = 'TCP'
+
+
+class EgressNetworkPolicyInternetAccessPolicyInternetDestinationInternetDestinationType(Enum):
+
+    FQDN = 'FQDN'
+
+
+@dataclass
+class EgressNetworkPolicyInternetAccessPolicyLogOnlyMode:
+    log_only_mode_type: Optional[EgressNetworkPolicyInternetAccessPolicyLogOnlyModeLogOnlyModeType] = None
+
+    workloads: Optional[List[EgressNetworkPolicyInternetAccessPolicyLogOnlyModeWorkloadType]] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the EgressNetworkPolicyInternetAccessPolicyLogOnlyMode into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.log_only_mode_type is not None: body['log_only_mode_type'] = self.log_only_mode_type.value
+        if self.workloads: body['workloads'] = [v.value for v in self.workloads]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EgressNetworkPolicyInternetAccessPolicyLogOnlyMode into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.log_only_mode_type is not None: body['log_only_mode_type'] = self.log_only_mode_type
+        if self.workloads: body['workloads'] = self.workloads
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> EgressNetworkPolicyInternetAccessPolicyLogOnlyMode:
+        """Deserializes the EgressNetworkPolicyInternetAccessPolicyLogOnlyMode from a dictionary."""
+        return cls(log_only_mode_type=_enum(
+            d, 'log_only_mode_type', EgressNetworkPolicyInternetAccessPolicyLogOnlyModeLogOnlyModeType),
+                   workloads=_repeated_enum(d, 'workloads',
+                                            EgressNetworkPolicyInternetAccessPolicyLogOnlyModeWorkloadType))
+
+
+class EgressNetworkPolicyInternetAccessPolicyLogOnlyModeLogOnlyModeType(Enum):
+
+    ALL_SERVICES = 'ALL_SERVICES'
+    SELECTED_SERVICES = 'SELECTED_SERVICES'
+
+
+class EgressNetworkPolicyInternetAccessPolicyLogOnlyModeWorkloadType(Enum):
+    """The values should match the list of workloads used in networkconfig.proto"""
+
+    DBSQL = 'DBSQL'
+    ML_SERVING = 'ML_SERVING'
+
+
+class EgressNetworkPolicyInternetAccessPolicyRestrictionMode(Enum):
+    """At which level can Databricks and Databricks managed compute access Internet. FULL_ACCESS:
+    Databricks can access Internet. No blocking rules will apply. RESTRICTED_ACCESS: Databricks can
+    only access explicitly allowed internet and storage destinations, as well as UC connections and
+    external locations. PRIVATE_ACCESS_ONLY (not used): Databricks can only access destinations via
+    private link."""
+
+    FULL_ACCESS = 'FULL_ACCESS'
+    PRIVATE_ACCESS_ONLY = 'PRIVATE_ACCESS_ONLY'
+    RESTRICTED_ACCESS = 'RESTRICTED_ACCESS'
+
+
+@dataclass
+class EgressNetworkPolicyInternetAccessPolicyStorageDestination:
+    """Users can specify accessible storage destinations."""
+
+    allowed_paths: Optional[List[str]] = None
+
+    azure_container: Optional[str] = None
+
+    azure_dns_zone: Optional[str] = None
+
+    azure_storage_account: Optional[str] = None
+
+    azure_storage_service: Optional[str] = None
+
+    bucket_name: Optional[str] = None
+
+    region: Optional[str] = None
+
+    type: Optional[EgressNetworkPolicyInternetAccessPolicyStorageDestinationStorageDestinationType] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the EgressNetworkPolicyInternetAccessPolicyStorageDestination into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.allowed_paths: body['allowed_paths'] = [v for v in self.allowed_paths]
+        if self.azure_container is not None: body['azure_container'] = self.azure_container
+        if self.azure_dns_zone is not None: body['azure_dns_zone'] = self.azure_dns_zone
+        if self.azure_storage_account is not None: body['azure_storage_account'] = self.azure_storage_account
+        if self.azure_storage_service is not None: body['azure_storage_service'] = self.azure_storage_service
+        if self.bucket_name is not None: body['bucket_name'] = self.bucket_name
+        if self.region is not None: body['region'] = self.region
+        if self.type is not None: body['type'] = self.type.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EgressNetworkPolicyInternetAccessPolicyStorageDestination into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.allowed_paths: body['allowed_paths'] = self.allowed_paths
+        if self.azure_container is not None: body['azure_container'] = self.azure_container
+        if self.azure_dns_zone is not None: body['azure_dns_zone'] = self.azure_dns_zone
+        if self.azure_storage_account is not None: body['azure_storage_account'] = self.azure_storage_account
+        if self.azure_storage_service is not None: body['azure_storage_service'] = self.azure_storage_service
+        if self.bucket_name is not None: body['bucket_name'] = self.bucket_name
+        if self.region is not None: body['region'] = self.region
+        if self.type is not None: body['type'] = self.type
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> EgressNetworkPolicyInternetAccessPolicyStorageDestination:
+        """Deserializes the EgressNetworkPolicyInternetAccessPolicyStorageDestination from a dictionary."""
+        return cls(allowed_paths=d.get('allowed_paths', None),
+                   azure_container=d.get('azure_container', None),
+                   azure_dns_zone=d.get('azure_dns_zone', None),
+                   azure_storage_account=d.get('azure_storage_account', None),
+                   azure_storage_service=d.get('azure_storage_service', None),
+                   bucket_name=d.get('bucket_name', None),
+                   region=d.get('region', None),
+                   type=_enum(
+                       d, 'type',
+                       EgressNetworkPolicyInternetAccessPolicyStorageDestinationStorageDestinationType))
+
+
+class EgressNetworkPolicyInternetAccessPolicyStorageDestinationStorageDestinationType(Enum):
+
+    AWS_S3 = 'AWS_S3'
+    AZURE_STORAGE = 'AZURE_STORAGE'
+    CLOUDFLARE_R2 = 'CLOUDFLARE_R2'
+    GOOGLE_CLOUD_STORAGE = 'GOOGLE_CLOUD_STORAGE'
+
+
 @dataclass
 class EmailConfig:
     addresses: Optional[List[str]] = None
@@ -1083,6 +1680,12 @@ class EmailConfig:
         if self.addresses: body['addresses'] = [v for v in self.addresses]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EmailConfig into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.addresses: body['addresses'] = self.addresses
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EmailConfig:
         """Deserializes the EmailConfig from a dictionary."""
@@ -1097,6 +1700,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."""
@@ -1115,6 +1723,12 @@ class EnhancedSecurityMonitoring:
         if self.is_enabled is not None: body['is_enabled'] = self.is_enabled
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EnhancedSecurityMonitoring into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.is_enabled is not None: body['is_enabled'] = self.is_enabled
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EnhancedSecurityMonitoring:
         """Deserializes the EnhancedSecurityMonitoring from a dictionary."""
@@ -1151,6 +1765,15 @@ class EnhancedSecurityMonitoringSetting:
         if self.setting_name is not None: body['setting_name'] = self.setting_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EnhancedSecurityMonitoringSetting into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.enhanced_security_monitoring_workspace:
+            body['enhanced_security_monitoring_workspace'] = self.enhanced_security_monitoring_workspace
+        if self.etag is not None: body['etag'] = self.etag
+        if self.setting_name is not None: body['setting_name'] = self.setting_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EnhancedSecurityMonitoringSetting:
         """Deserializes the EnhancedSecurityMonitoringSetting from a dictionary."""
@@ -1172,6 +1795,12 @@ class EsmEnablementAccount:
         if self.is_enforced is not None: body['is_enforced'] = self.is_enforced
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EsmEnablementAccount into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.is_enforced is not None: body['is_enforced'] = self.is_enforced
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EsmEnablementAccount:
         """Deserializes the EsmEnablementAccount from a dictionary."""
@@ -1205,6 +1834,14 @@ class EsmEnablementAccountSetting:
         if self.setting_name is not None: body['setting_name'] = self.setting_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EsmEnablementAccountSetting into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.esm_enablement_account: body['esm_enablement_account'] = self.esm_enablement_account
+        if self.etag is not None: body['etag'] = self.etag
+        if self.setting_name is not None: body['setting_name'] = self.setting_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EsmEnablementAccountSetting:
         """Deserializes the EsmEnablementAccountSetting from a dictionary."""
@@ -1242,6 +1879,16 @@ class ExchangeToken:
         if self.token_type is not None: body['tokenType'] = self.token_type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ExchangeToken into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.credential is not None: body['credential'] = self.credential
+        if self.credential_eol_time is not None: body['credentialEolTime'] = self.credential_eol_time
+        if self.owner_id is not None: body['ownerId'] = self.owner_id
+        if self.scopes: body['scopes'] = self.scopes
+        if self.token_type is not None: body['tokenType'] = self.token_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ExchangeToken:
         """Deserializes the ExchangeToken from a dictionary."""
@@ -1273,6 +1920,14 @@ class ExchangeTokenRequest:
         if self.token_type: body['tokenType'] = [v.value for v in self.token_type]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ExchangeTokenRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.partition_id: body['partitionId'] = self.partition_id
+        if self.scopes: body['scopes'] = self.scopes
+        if self.token_type: body['tokenType'] = self.token_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ExchangeTokenRequest:
         """Deserializes the ExchangeTokenRequest from a dictionary."""
@@ -1293,6 +1948,12 @@ class ExchangeTokenResponse:
         if self.values: body['values'] = [v.as_dict() for v in self.values]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ExchangeTokenResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.values: body['values'] = self.values
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ExchangeTokenResponse:
         """Deserializes the ExchangeTokenResponse from a dictionary."""
@@ -1312,6 +1973,12 @@ class FetchIpAccessListResponse:
         if self.ip_access_list: body['ip_access_list'] = self.ip_access_list.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the FetchIpAccessListResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.ip_access_list: body['ip_access_list'] = self.ip_access_list
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> FetchIpAccessListResponse:
         """Deserializes the FetchIpAccessListResponse from a dictionary."""
@@ -1349,6 +2016,17 @@ class GenericWebhookConfig:
         if self.username_set is not None: body['username_set'] = self.username_set
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GenericWebhookConfig into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.password is not None: body['password'] = self.password
+        if self.password_set is not None: body['password_set'] = self.password_set
+        if self.url is not None: body['url'] = self.url
+        if self.url_set is not None: body['url_set'] = self.url_set
+        if self.username is not None: body['username'] = self.username
+        if self.username_set is not None: body['username_set'] = self.username_set
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GenericWebhookConfig:
         """Deserializes the GenericWebhookConfig from a dictionary."""
@@ -1371,6 +2049,12 @@ class GetIpAccessListResponse:
         if self.ip_access_list: body['ip_access_list'] = self.ip_access_list.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GetIpAccessListResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.ip_access_list: body['ip_access_list'] = self.ip_access_list
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GetIpAccessListResponse:
         """Deserializes the GetIpAccessListResponse from a dictionary."""
@@ -1389,6 +2073,12 @@ class GetIpAccessListsResponse:
         if self.ip_access_lists: body['ip_access_lists'] = [v.as_dict() for v in self.ip_access_lists]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GetIpAccessListsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.ip_access_lists: body['ip_access_lists'] = self.ip_access_lists
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GetIpAccessListsResponse:
         """Deserializes the GetIpAccessListsResponse from a dictionary."""
@@ -1406,6 +2096,12 @@ class GetTokenPermissionLevelsResponse:
         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 GetTokenPermissionLevelsResponse 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]) -> GetTokenPermissionLevelsResponse:
         """Deserializes the GetTokenPermissionLevelsResponse from a dictionary."""
@@ -1424,6 +2120,12 @@ class GetTokenResponse:
         if self.token_info: body['token_info'] = self.token_info.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GetTokenResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.token_info: body['token_info'] = self.token_info
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GetTokenResponse:
         """Deserializes the GetTokenResponse from a dictionary."""
@@ -1481,6 +2183,21 @@ class IpAccessListInfo:
         if self.updated_by is not None: body['updated_by'] = self.updated_by
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the IpAccessListInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.address_count is not None: body['address_count'] = self.address_count
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.created_by is not None: body['created_by'] = self.created_by
+        if self.enabled is not None: body['enabled'] = self.enabled
+        if self.ip_addresses: body['ip_addresses'] = self.ip_addresses
+        if self.label is not None: body['label'] = self.label
+        if self.list_id is not None: body['list_id'] = self.list_id
+        if self.list_type is not None: body['list_type'] = self.list_type
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.updated_by is not None: body['updated_by'] = self.updated_by
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> IpAccessListInfo:
         """Deserializes the IpAccessListInfo from a dictionary."""
@@ -1508,6 +2225,12 @@ class ListIpAccessListResponse:
         if self.ip_access_lists: body['ip_access_lists'] = [v.as_dict() for v in self.ip_access_lists]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListIpAccessListResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.ip_access_lists: body['ip_access_lists'] = self.ip_access_lists
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListIpAccessListResponse:
         """Deserializes the ListIpAccessListResponse from a dictionary."""
@@ -1529,6 +2252,13 @@ class ListNccAzurePrivateEndpointRulesResponse:
         if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListNccAzurePrivateEndpointRulesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.items: body['items'] = self.items
+        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListNccAzurePrivateEndpointRulesResponse:
         """Deserializes the ListNccAzurePrivateEndpointRulesResponse from a dictionary."""
@@ -1551,6 +2281,13 @@ class ListNetworkConnectivityConfigurationsResponse:
         if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListNetworkConnectivityConfigurationsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.items: body['items'] = self.items
+        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListNetworkConnectivityConfigurationsResponse:
         """Deserializes the ListNetworkConnectivityConfigurationsResponse from a dictionary."""
@@ -1572,6 +2309,13 @@ class ListNotificationDestinationsResponse:
         if self.results: body['results'] = [v.as_dict() for v in self.results]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListNotificationDestinationsResponse 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]) -> ListNotificationDestinationsResponse:
         """Deserializes the ListNotificationDestinationsResponse from a dictionary."""
@@ -1598,6 +2342,14 @@ class ListNotificationDestinationsResult:
         if self.id is not None: body['id'] = self.id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListNotificationDestinationsResult into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.destination_type is not None: body['destination_type'] = self.destination_type
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.id is not None: body['id'] = self.id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListNotificationDestinationsResult:
         """Deserializes the ListNotificationDestinationsResult from a dictionary."""
@@ -1617,6 +2369,12 @@ class ListPublicTokensResponse:
         if self.token_infos: body['token_infos'] = [v.as_dict() for v in self.token_infos]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListPublicTokensResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.token_infos: body['token_infos'] = self.token_infos
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListPublicTokensResponse:
         """Deserializes the ListPublicTokensResponse from a dictionary."""
@@ -1636,6 +2394,12 @@ class ListTokensResponse:
         if self.token_infos: body['token_infos'] = [v.as_dict() for v in self.token_infos]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListTokensResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.token_infos: body['token_infos'] = self.token_infos
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListTokensResponse:
         """Deserializes the ListTokensResponse from a dictionary."""
@@ -1667,6 +2431,13 @@ class MicrosoftTeamsConfig:
         if self.url_set is not None: body['url_set'] = self.url_set
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the MicrosoftTeamsConfig into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.url is not None: body['url'] = self.url
+        if self.url_set is not None: body['url_set'] = self.url_set
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> MicrosoftTeamsConfig:
         """Deserializes the MicrosoftTeamsConfig from a dictionary."""
@@ -1688,6 +2459,12 @@ class NccAwsStableIpRule:
         if self.cidr_blocks: body['cidr_blocks'] = [v for v in self.cidr_blocks]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the NccAwsStableIpRule into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.cidr_blocks: body['cidr_blocks'] = self.cidr_blocks
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> NccAwsStableIpRule:
         """Deserializes the NccAwsStableIpRule from a dictionary."""
@@ -1745,7 +2522,23 @@ class NccAzurePrivateEndpointRule:
         if self.deactivated is not None: body['deactivated'] = self.deactivated
         if self.deactivated_at is not None: body['deactivated_at'] = self.deactivated_at
         if self.endpoint_name is not None: body['endpoint_name'] = self.endpoint_name
-        if self.group_id is not None: body['group_id'] = self.group_id.value
+        if self.group_id is not None: body['group_id'] = self.group_id.value
+        if self.network_connectivity_config_id is not None:
+            body['network_connectivity_config_id'] = self.network_connectivity_config_id
+        if self.resource_id is not None: body['resource_id'] = self.resource_id
+        if self.rule_id is not None: body['rule_id'] = self.rule_id
+        if self.updated_time is not None: body['updated_time'] = self.updated_time
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the NccAzurePrivateEndpointRule into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.connection_state is not None: body['connection_state'] = self.connection_state
+        if self.creation_time is not None: body['creation_time'] = self.creation_time
+        if self.deactivated is not None: body['deactivated'] = self.deactivated
+        if self.deactivated_at is not None: body['deactivated_at'] = self.deactivated_at
+        if self.endpoint_name is not None: body['endpoint_name'] = self.endpoint_name
+        if self.group_id is not None: body['group_id'] = self.group_id
         if self.network_connectivity_config_id is not None:
             body['network_connectivity_config_id'] = self.network_connectivity_config_id
         if self.resource_id is not None: body['resource_id'] = self.resource_id
@@ -1820,6 +2613,14 @@ class NccAzureServiceEndpointRule:
         if self.target_services: body['target_services'] = [v for v in self.target_services]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the NccAzureServiceEndpointRule into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.subnets: body['subnets'] = self.subnets
+        if self.target_region is not None: body['target_region'] = self.target_region
+        if self.target_services: body['target_services'] = self.target_services
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> NccAzureServiceEndpointRule:
         """Deserializes the NccAzureServiceEndpointRule from a dictionary."""
@@ -1849,6 +2650,13 @@ class NccEgressConfig:
         if self.target_rules: body['target_rules'] = self.target_rules.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the NccEgressConfig into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.default_rules: body['default_rules'] = self.default_rules
+        if self.target_rules: body['target_rules'] = self.target_rules
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> NccEgressConfig:
         """Deserializes the NccEgressConfig from a dictionary."""
@@ -1878,6 +2686,14 @@ class NccEgressDefaultRules:
             body['azure_service_endpoint_rule'] = self.azure_service_endpoint_rule.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the NccEgressDefaultRules into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.aws_stable_ip_rule: body['aws_stable_ip_rule'] = self.aws_stable_ip_rule
+        if self.azure_service_endpoint_rule:
+            body['azure_service_endpoint_rule'] = self.azure_service_endpoint_rule
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> NccEgressDefaultRules:
         """Deserializes the NccEgressDefaultRules from a dictionary."""
@@ -1900,6 +2716,13 @@ class NccEgressTargetRules:
             body['azure_private_endpoint_rules'] = [v.as_dict() for v in self.azure_private_endpoint_rules]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the NccEgressTargetRules into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.azure_private_endpoint_rules:
+            body['azure_private_endpoint_rules'] = self.azure_private_endpoint_rules
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> NccEgressTargetRules:
         """Deserializes the NccEgressTargetRules from a dictionary."""
@@ -1947,6 +2770,19 @@ class NetworkConnectivityConfiguration:
         if self.updated_time is not None: body['updated_time'] = self.updated_time
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the NetworkConnectivityConfiguration into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.account_id is not None: body['account_id'] = self.account_id
+        if self.creation_time is not None: body['creation_time'] = self.creation_time
+        if self.egress_config: body['egress_config'] = self.egress_config
+        if self.name is not None: body['name'] = self.name
+        if self.network_connectivity_config_id is not None:
+            body['network_connectivity_config_id'] = self.network_connectivity_config_id
+        if self.region is not None: body['region'] = self.region
+        if self.updated_time is not None: body['updated_time'] = self.updated_time
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> NetworkConnectivityConfiguration:
         """Deserializes the NetworkConnectivityConfiguration from a dictionary."""
@@ -1983,6 +2819,15 @@ class NotificationDestination:
         if self.id is not None: body['id'] = self.id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the NotificationDestination into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.config: body['config'] = self.config
+        if self.destination_type is not None: body['destination_type'] = self.destination_type
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.id is not None: body['id'] = self.id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> NotificationDestination:
         """Deserializes the NotificationDestination from a dictionary."""
@@ -2007,6 +2852,13 @@ class PagerdutyConfig:
         if self.integration_key_set is not None: body['integration_key_set'] = self.integration_key_set
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PagerdutyConfig into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.integration_key is not None: body['integration_key'] = self.integration_key
+        if self.integration_key_set is not None: body['integration_key_set'] = self.integration_key_set
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> PagerdutyConfig:
         """Deserializes the PagerdutyConfig from a dictionary."""
@@ -2027,6 +2879,12 @@ class PartitionId:
         if self.workspace_id is not None: body['workspaceId'] = self.workspace_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PartitionId into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.workspace_id is not None: body['workspaceId'] = self.workspace_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> PartitionId:
         """Deserializes the PartitionId from a dictionary."""
@@ -2048,6 +2906,12 @@ class PersonalComputeMessage:
         if self.value is not None: body['value'] = self.value.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PersonalComputeMessage 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]) -> PersonalComputeMessage:
         """Deserializes the PersonalComputeMessage from a dictionary."""
@@ -2091,6 +2955,14 @@ class PersonalComputeSetting:
         if self.setting_name is not None: body['setting_name'] = self.setting_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PersonalComputeSetting into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.etag is not None: body['etag'] = self.etag
+        if self.personal_compute: body['personal_compute'] = self.personal_compute
+        if self.setting_name is not None: body['setting_name'] = self.setting_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> PersonalComputeSetting:
         """Deserializes the PersonalComputeSetting from a dictionary."""
@@ -2122,6 +2994,15 @@ class PublicTokenInfo:
         if self.token_id is not None: body['token_id'] = self.token_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PublicTokenInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.comment is not None: body['comment'] = self.comment
+        if self.creation_time is not None: body['creation_time'] = self.creation_time
+        if self.expiry_time is not None: body['expiry_time'] = self.expiry_time
+        if self.token_id is not None: body['token_id'] = self.token_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> PublicTokenInfo:
         """Deserializes the PublicTokenInfo from a dictionary."""
@@ -2162,6 +3043,16 @@ class ReplaceIpAccessList:
         if self.list_type is not None: body['list_type'] = self.list_type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ReplaceIpAccessList into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.enabled is not None: body['enabled'] = self.enabled
+        if self.ip_access_list_id is not None: body['ip_access_list_id'] = self.ip_access_list_id
+        if self.ip_addresses: body['ip_addresses'] = self.ip_addresses
+        if self.label is not None: body['label'] = self.label
+        if self.list_type is not None: body['list_type'] = self.list_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ReplaceIpAccessList:
         """Deserializes the ReplaceIpAccessList from a dictionary."""
@@ -2180,6 +3071,11 @@ class ReplaceResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ReplaceResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ReplaceResponse:
         """Deserializes the ReplaceResponse from a dictionary."""
@@ -2196,6 +3092,12 @@ class RestrictWorkspaceAdminsMessage:
         if self.status is not None: body['status'] = self.status.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the RestrictWorkspaceAdminsMessage into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.status is not None: body['status'] = self.status
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> RestrictWorkspaceAdminsMessage:
         """Deserializes the RestrictWorkspaceAdminsMessage from a dictionary."""
@@ -2235,6 +3137,14 @@ class RestrictWorkspaceAdminsSetting:
         if self.setting_name is not None: body['setting_name'] = self.setting_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the RestrictWorkspaceAdminsSetting into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.etag is not None: body['etag'] = self.etag
+        if self.restrict_workspace_admins: body['restrict_workspace_admins'] = self.restrict_workspace_admins
+        if self.setting_name is not None: body['setting_name'] = self.setting_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> RestrictWorkspaceAdminsSetting:
         """Deserializes the RestrictWorkspaceAdminsSetting from a dictionary."""
@@ -2255,6 +3165,12 @@ class RevokeTokenRequest:
         if self.token_id is not None: body['token_id'] = self.token_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the RevokeTokenRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.token_id is not None: body['token_id'] = self.token_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> RevokeTokenRequest:
         """Deserializes the RevokeTokenRequest from a dictionary."""
@@ -2269,6 +3185,11 @@ class RevokeTokenResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the RevokeTokenResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> RevokeTokenResponse:
         """Deserializes the RevokeTokenResponse from a dictionary."""
@@ -2283,6 +3204,11 @@ class SetStatusResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the SetStatusResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> SetStatusResponse:
         """Deserializes the SetStatusResponse from a dictionary."""
@@ -2304,6 +3230,13 @@ class SlackConfig:
         if self.url_set is not None: body['url_set'] = self.url_set
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the SlackConfig into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.url is not None: body['url'] = self.url
+        if self.url_set is not None: body['url_set'] = self.url_set
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> SlackConfig:
         """Deserializes the SlackConfig from a dictionary."""
@@ -2321,6 +3254,12 @@ class StringMessage:
         if self.value is not None: body['value'] = self.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the StringMessage 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]) -> StringMessage:
         """Deserializes the StringMessage from a dictionary."""
@@ -2351,6 +3290,16 @@ class TokenAccessControlRequest:
         if self.user_name is not None: body['user_name'] = self.user_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the TokenAccessControlRequest 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]) -> TokenAccessControlRequest:
         """Deserializes the TokenAccessControlRequest from a dictionary."""
@@ -2388,6 +3337,17 @@ class TokenAccessControlResponse:
         if self.user_name is not None: body['user_name'] = self.user_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the TokenAccessControlResponse 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]) -> TokenAccessControlResponse:
         """Deserializes the TokenAccessControlResponse from a dictionary."""
@@ -2441,6 +3401,20 @@ class TokenInfo:
         if self.workspace_id is not None: body['workspace_id'] = self.workspace_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the TokenInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.comment is not None: body['comment'] = self.comment
+        if self.created_by_id is not None: body['created_by_id'] = self.created_by_id
+        if self.created_by_username is not None: body['created_by_username'] = self.created_by_username
+        if self.creation_time is not None: body['creation_time'] = self.creation_time
+        if self.expiry_time is not None: body['expiry_time'] = self.expiry_time
+        if self.last_used_day is not None: body['last_used_day'] = self.last_used_day
+        if self.owner_id is not None: body['owner_id'] = self.owner_id
+        if self.token_id is not None: body['token_id'] = self.token_id
+        if self.workspace_id is not None: body['workspace_id'] = self.workspace_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> TokenInfo:
         """Deserializes the TokenInfo from a dictionary."""
@@ -2472,6 +3446,14 @@ class TokenPermission:
         if self.permission_level is not None: body['permission_level'] = self.permission_level.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the TokenPermission 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]) -> TokenPermission:
         """Deserializes the TokenPermission from a dictionary."""
@@ -2503,6 +3485,14 @@ class TokenPermissions:
         if self.object_type is not None: body['object_type'] = self.object_type
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the TokenPermissions 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]) -> TokenPermissions:
         """Deserializes the TokenPermissions from a dictionary."""
@@ -2525,6 +3515,13 @@ class TokenPermissionsDescription:
         if self.permission_level is not None: body['permission_level'] = self.permission_level.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the TokenPermissionsDescription 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]) -> TokenPermissionsDescription:
         """Deserializes the TokenPermissionsDescription from a dictionary."""
@@ -2543,6 +3540,12 @@ class TokenPermissionsRequest:
             body['access_control_list'] = [v.as_dict() for v in self.access_control_list]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the TokenPermissionsRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.access_control_list: body['access_control_list'] = self.access_control_list
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> TokenPermissionsRequest:
         """Deserializes the TokenPermissionsRequest from a dictionary."""
@@ -2578,6 +3581,14 @@ class UpdateAibiDashboardEmbeddingAccessPolicySettingRequest:
         if self.setting: body['setting'] = self.setting.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateAibiDashboardEmbeddingAccessPolicySettingRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.allow_missing is not None: body['allow_missing'] = self.allow_missing
+        if self.field_mask is not None: body['field_mask'] = self.field_mask
+        if self.setting: body['setting'] = self.setting
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateAibiDashboardEmbeddingAccessPolicySettingRequest:
         """Deserializes the UpdateAibiDashboardEmbeddingAccessPolicySettingRequest from a dictionary."""
@@ -2608,6 +3619,14 @@ class UpdateAibiDashboardEmbeddingApprovedDomainsSettingRequest:
         if self.setting: body['setting'] = self.setting.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateAibiDashboardEmbeddingApprovedDomainsSettingRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.allow_missing is not None: body['allow_missing'] = self.allow_missing
+        if self.field_mask is not None: body['field_mask'] = self.field_mask
+        if self.setting: body['setting'] = self.setting
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateAibiDashboardEmbeddingApprovedDomainsSettingRequest:
         """Deserializes the UpdateAibiDashboardEmbeddingApprovedDomainsSettingRequest from a dictionary."""
@@ -2638,6 +3657,14 @@ class UpdateAutomaticClusterUpdateSettingRequest:
         if self.setting: body['setting'] = self.setting.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateAutomaticClusterUpdateSettingRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.allow_missing is not None: body['allow_missing'] = self.allow_missing
+        if self.field_mask is not None: body['field_mask'] = self.field_mask
+        if self.setting: body['setting'] = self.setting
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateAutomaticClusterUpdateSettingRequest:
         """Deserializes the UpdateAutomaticClusterUpdateSettingRequest from a dictionary."""
@@ -2668,6 +3695,14 @@ class UpdateComplianceSecurityProfileSettingRequest:
         if self.setting: body['setting'] = self.setting.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateComplianceSecurityProfileSettingRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.allow_missing is not None: body['allow_missing'] = self.allow_missing
+        if self.field_mask is not None: body['field_mask'] = self.field_mask
+        if self.setting: body['setting'] = self.setting
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateComplianceSecurityProfileSettingRequest:
         """Deserializes the UpdateComplianceSecurityProfileSettingRequest from a dictionary."""
@@ -2698,6 +3733,14 @@ class UpdateCspEnablementAccountSettingRequest:
         if self.setting: body['setting'] = self.setting.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateCspEnablementAccountSettingRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.allow_missing is not None: body['allow_missing'] = self.allow_missing
+        if self.field_mask is not None: body['field_mask'] = self.field_mask
+        if self.setting: body['setting'] = self.setting
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateCspEnablementAccountSettingRequest:
         """Deserializes the UpdateCspEnablementAccountSettingRequest from a dictionary."""
@@ -2735,6 +3778,14 @@ class UpdateDefaultNamespaceSettingRequest:
         if self.setting: body['setting'] = self.setting.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateDefaultNamespaceSettingRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.allow_missing is not None: body['allow_missing'] = self.allow_missing
+        if self.field_mask is not None: body['field_mask'] = self.field_mask
+        if self.setting: body['setting'] = self.setting
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateDefaultNamespaceSettingRequest:
         """Deserializes the UpdateDefaultNamespaceSettingRequest from a dictionary."""
@@ -2765,6 +3816,14 @@ class UpdateDisableLegacyAccessRequest:
         if self.setting: body['setting'] = self.setting.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateDisableLegacyAccessRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.allow_missing is not None: body['allow_missing'] = self.allow_missing
+        if self.field_mask is not None: body['field_mask'] = self.field_mask
+        if self.setting: body['setting'] = self.setting
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateDisableLegacyAccessRequest:
         """Deserializes the UpdateDisableLegacyAccessRequest from a dictionary."""
@@ -2795,6 +3854,14 @@ class UpdateDisableLegacyDbfsRequest:
         if self.setting: body['setting'] = self.setting.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateDisableLegacyDbfsRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.allow_missing is not None: body['allow_missing'] = self.allow_missing
+        if self.field_mask is not None: body['field_mask'] = self.field_mask
+        if self.setting: body['setting'] = self.setting
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateDisableLegacyDbfsRequest:
         """Deserializes the UpdateDisableLegacyDbfsRequest from a dictionary."""
@@ -2825,6 +3892,14 @@ class UpdateDisableLegacyFeaturesRequest:
         if self.setting: body['setting'] = self.setting.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateDisableLegacyFeaturesRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.allow_missing is not None: body['allow_missing'] = self.allow_missing
+        if self.field_mask is not None: body['field_mask'] = self.field_mask
+        if self.setting: body['setting'] = self.setting
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateDisableLegacyFeaturesRequest:
         """Deserializes the UpdateDisableLegacyFeaturesRequest from a dictionary."""
@@ -2855,6 +3930,14 @@ class UpdateEnhancedSecurityMonitoringSettingRequest:
         if self.setting: body['setting'] = self.setting.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateEnhancedSecurityMonitoringSettingRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.allow_missing is not None: body['allow_missing'] = self.allow_missing
+        if self.field_mask is not None: body['field_mask'] = self.field_mask
+        if self.setting: body['setting'] = self.setting
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateEnhancedSecurityMonitoringSettingRequest:
         """Deserializes the UpdateEnhancedSecurityMonitoringSettingRequest from a dictionary."""
@@ -2885,6 +3968,14 @@ class UpdateEsmEnablementAccountSettingRequest:
         if self.setting: body['setting'] = self.setting.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateEsmEnablementAccountSettingRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.allow_missing is not None: body['allow_missing'] = self.allow_missing
+        if self.field_mask is not None: body['field_mask'] = self.field_mask
+        if self.setting: body['setting'] = self.setting
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateEsmEnablementAccountSettingRequest:
         """Deserializes the UpdateEsmEnablementAccountSettingRequest from a dictionary."""
@@ -2924,6 +4015,16 @@ class UpdateIpAccessList:
         if self.list_type is not None: body['list_type'] = self.list_type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateIpAccessList into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.enabled is not None: body['enabled'] = self.enabled
+        if self.ip_access_list_id is not None: body['ip_access_list_id'] = self.ip_access_list_id
+        if self.ip_addresses: body['ip_addresses'] = self.ip_addresses
+        if self.label is not None: body['label'] = self.label
+        if self.list_type is not None: body['list_type'] = self.list_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateIpAccessList:
         """Deserializes the UpdateIpAccessList from a dictionary."""
@@ -2953,6 +4054,14 @@ class UpdateNotificationDestinationRequest:
         if self.id is not None: body['id'] = self.id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateNotificationDestinationRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.config: body['config'] = self.config
+        if self.display_name is not None: body['display_name'] = self.display_name
+        if self.id is not None: body['id'] = self.id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateNotificationDestinationRequest:
         """Deserializes the UpdateNotificationDestinationRequest from a dictionary."""
@@ -2983,6 +4092,14 @@ class UpdatePersonalComputeSettingRequest:
         if self.setting: body['setting'] = self.setting.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdatePersonalComputeSettingRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.allow_missing is not None: body['allow_missing'] = self.allow_missing
+        if self.field_mask is not None: body['field_mask'] = self.field_mask
+        if self.setting: body['setting'] = self.setting
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdatePersonalComputeSettingRequest:
         """Deserializes the UpdatePersonalComputeSettingRequest from a dictionary."""
@@ -2999,6 +4116,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."""
@@ -3027,6 +4149,14 @@ class UpdateRestrictWorkspaceAdminsSettingRequest:
         if self.setting: body['setting'] = self.setting.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateRestrictWorkspaceAdminsSettingRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.allow_missing is not None: body['allow_missing'] = self.allow_missing
+        if self.field_mask is not None: body['field_mask'] = self.field_mask
+        if self.setting: body['setting'] = self.setting
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateRestrictWorkspaceAdminsSettingRequest:
         """Deserializes the UpdateRestrictWorkspaceAdminsSettingRequest from a dictionary."""
@@ -3292,6 +4422,33 @@ class AibiDashboardEmbeddingAccessPolicyAPI:
     def __init__(self, api_client):
         self._api = api_client
 
+    def delete(self,
+               *,
+               etag: Optional[str] = None) -> DeleteAibiDashboardEmbeddingAccessPolicySettingResponse:
+        """Delete the AI/BI dashboard embedding access policy.
+        
+        Delete the AI/BI dashboard embedding access policy, reverting back to the default.
+        
+        :param etag: str (optional)
+          etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
+          optimistic concurrency control as a way to help prevent simultaneous writes of a setting overwriting
+          each other. It is strongly suggested that systems make use of the etag in the read -> delete pattern
+          to perform setting deletions in order to avoid race conditions. That is, get an etag from a GET
+          request, and pass it with the DELETE request to identify the rule set version you are deleting.
+        
+        :returns: :class:`DeleteAibiDashboardEmbeddingAccessPolicySettingResponse`
+        """
+
+        query = {}
+        if etag is not None: query['etag'] = etag
+        headers = {'Accept': 'application/json', }
+
+        res = self._api.do('DELETE',
+                           '/api/2.0/settings/types/aibi_dash_embed_ws_acc_policy/names/default',
+                           query=query,
+                           headers=headers)
+        return DeleteAibiDashboardEmbeddingAccessPolicySettingResponse.from_dict(res)
+
     def get(self, *, etag: Optional[str] = None) -> AibiDashboardEmbeddingAccessPolicySetting:
         """Retrieve the AI/BI dashboard embedding access policy.
         
@@ -3354,6 +4511,34 @@ class AibiDashboardEmbeddingApprovedDomainsAPI:
     def __init__(self, api_client):
         self._api = api_client
 
+    def delete(self,
+               *,
+               etag: Optional[str] = None) -> DeleteAibiDashboardEmbeddingApprovedDomainsSettingResponse:
+        """Delete AI/BI dashboard embedding approved domains.
+        
+        Delete the list of domains approved to host embedded AI/BI dashboards, reverting back to the default
+        empty list.
+        
+        :param etag: str (optional)
+          etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
+          optimistic concurrency control as a way to help prevent simultaneous writes of a setting overwriting
+          each other. It is strongly suggested that systems make use of the etag in the read -> delete pattern
+          to perform setting deletions in order to avoid race conditions. That is, get an etag from a GET
+          request, and pass it with the DELETE request to identify the rule set version you are deleting.
+        
+        :returns: :class:`DeleteAibiDashboardEmbeddingApprovedDomainsSettingResponse`
+        """
+
+        query = {}
+        if etag is not None: query['etag'] = etag
+        headers = {'Accept': 'application/json', }
+
+        res = self._api.do('DELETE',
+                           '/api/2.0/settings/types/aibi_dash_embed_ws_apprvd_domains/names/default',
+                           query=query,
+                           headers=headers)
+        return DeleteAibiDashboardEmbeddingApprovedDomainsSettingResponse.from_dict(res)
+
     def get(self, *, etag: Optional[str] = None) -> AibiDashboardEmbeddingApprovedDomainsSetting:
         """Retrieve the list of domains approved to host embedded AI/BI dashboards.