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

databricks/sdk/service/settings.py

@@ -731,49 +731,6 @@ class Config:
         )
 
 
-@dataclass
-class CreateIpAccessList:
-    """Details required to configure a block list or allow list."""
-
-    label: str
-    """Label for the IP access list. This **cannot** be empty."""
-
-    list_type: ListType
-
-    ip_addresses: Optional[List[str]] = None
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateIpAccessList into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.ip_addresses:
-            body["ip_addresses"] = [v for v in 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.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."""
-        return cls(
-            ip_addresses=d.get("ip_addresses", None),
-            label=d.get("label", None),
-            list_type=_enum(d, "list_type", ListType),
-        )
-
-
 @dataclass
 class CreateIpAccessListResponse:
     """An IP access list was successfully created."""
@@ -837,83 +794,6 @@ class CreateNetworkConnectivityConfiguration:
         return cls(name=d.get("name", None), region=d.get("region", None))
 
 
-@dataclass
-class CreateNotificationDestinationRequest:
-    config: Optional[Config] = None
-    """The configuration for the notification destination. Must wrap EXACTLY one of the nested configs."""
-
-    display_name: Optional[str] = None
-    """The display name for the notification destination."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateNotificationDestinationRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.config:
-            body["config"] = self.config.as_dict()
-        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."""
-        return cls(config=_from_dict(d, "config", Config), display_name=d.get("display_name", None))
-
-
-@dataclass
-class CreateOboTokenRequest:
-    """Configuration details for creating on-behalf tokens."""
-
-    application_id: str
-    """Application ID of the service principal."""
-
-    comment: Optional[str] = None
-    """Comment that describes the purpose of the token."""
-
-    lifetime_seconds: Optional[int] = None
-    """The number of seconds before the token expires."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateOboTokenRequest into a dictionary suitable for use as a JSON request body."""
-        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
-
-    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."""
-        return cls(
-            application_id=d.get("application_id", None),
-            comment=d.get("comment", None),
-            lifetime_seconds=d.get("lifetime_seconds", None),
-        )
-
-
 @dataclass
 class CreateOboTokenResponse:
     """An on-behalf token was successfully created for the service principal."""
@@ -1020,40 +900,6 @@ class CreatePrivateEndpointRule:
         )
 
 
-@dataclass
-class CreateTokenRequest:
-    comment: Optional[str] = None
-    """Optional description to attach to the token."""
-
-    lifetime_seconds: Optional[int] = None
-    """The lifetime of the token, in seconds.
-    
-    If the lifetime is not specified, this token remains valid indefinitely."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateTokenRequest into a dictionary suitable for use as a JSON request body."""
-        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
-
-    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."""
-        return cls(comment=d.get("comment", None), lifetime_seconds=d.get("lifetime_seconds", None))
-
-
 @dataclass
 class CreateTokenResponse:
     token_info: Optional[PublicTokenInfo] = None
@@ -1445,6 +1291,56 @@ class DefaultNamespaceSetting:
         )
 
 
+@dataclass
+class DefaultWarehouseId:
+    string_val: StringMessage
+
+    etag: Optional[str] = None
+    """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
+    -> update pattern to perform setting updates in order to avoid race conditions. That is, get an
+    etag from a GET request, and pass it with the PATCH request to identify the setting version you
+    are updating."""
+
+    setting_name: Optional[str] = None
+    """Name of the corresponding setting. This field is populated in the response, but it will not be
+    respected even if it's set in the request body. The setting name in the path parameter will be
+    respected instead. Setting name is required to be 'default' if the setting only has one instance
+    per workspace."""
+
+    def as_dict(self) -> dict:
+        """Serializes the DefaultWarehouseId into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.etag is not None:
+            body["etag"] = self.etag
+        if self.setting_name is not None:
+            body["setting_name"] = self.setting_name
+        if self.string_val:
+            body["string_val"] = self.string_val.as_dict()
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DefaultWarehouseId into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.etag is not None:
+            body["etag"] = self.etag
+        if self.setting_name is not None:
+            body["setting_name"] = self.setting_name
+        if self.string_val:
+            body["string_val"] = self.string_val
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> DefaultWarehouseId:
+        """Deserializes the DefaultWarehouseId from a dictionary."""
+        return cls(
+            etag=d.get("etag", None),
+            setting_name=d.get("setting_name", None),
+            string_val=_from_dict(d, "string_val", StringMessage),
+        )
+
+
 @dataclass
 class DeleteAccountIpAccessEnableResponse:
     """The etag is returned."""
@@ -1605,6 +1501,38 @@ class DeleteDefaultNamespaceSettingResponse:
         return cls(etag=d.get("etag", None))
 
 
+@dataclass
+class DeleteDefaultWarehouseIdResponse:
+    """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 DeleteDefaultWarehouseIdResponse 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 DeleteDefaultWarehouseIdResponse 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]) -> DeleteDefaultWarehouseIdResponse:
+        """Deserializes the DeleteDefaultWarehouseIdResponse from a dictionary."""
+        return cls(etag=d.get("etag", None))
+
+
 @dataclass
 class DeleteDisableLegacyAccessResponse:
     """The etag is returned."""
@@ -2914,51 +2842,6 @@ class ExchangeToken:
         )
 
 
-@dataclass
-class ExchangeTokenRequest:
-    """Exchange a token with the IdP"""
-
-    partition_id: PartitionId
-    """The partition of Credentials store"""
-
-    token_type: List[TokenType]
-    """A list of token types being requested"""
-
-    scopes: List[str]
-    """Array of scopes for the token request."""
-
-    def as_dict(self) -> dict:
-        """Serializes the ExchangeTokenRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.partition_id:
-            body["partitionId"] = self.partition_id.as_dict()
-        if self.scopes:
-            body["scopes"] = [v for v in self.scopes]
-        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."""
-        return cls(
-            partition_id=_from_dict(d, "partitionId", PartitionId),
-            scopes=d.get("scopes", None),
-            token_type=_repeated_enum(d, "tokenType", TokenType),
-        )
-
-
 @dataclass
 class ExchangeTokenResponse:
     """Exhanged tokens were successfully returned."""
@@ -4597,65 +4480,6 @@ class PublicTokenInfo:
         )
 
 
-@dataclass
-class ReplaceIpAccessList:
-    """Details required to replace an IP access list."""
-
-    label: str
-    """Label for the IP access list. This **cannot** be empty."""
-
-    list_type: ListType
-
-    enabled: bool
-    """Specifies whether this IP access list is enabled."""
-
-    ip_access_list_id: Optional[str] = None
-    """The ID for the corresponding IP access list"""
-
-    ip_addresses: Optional[List[str]] = None
-
-    def as_dict(self) -> dict:
-        """Serializes the ReplaceIpAccessList into a dictionary suitable for use as a JSON request body."""
-        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"] = [v for v in 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.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."""
-        return cls(
-            enabled=d.get("enabled", None),
-            ip_access_list_id=d.get("ip_access_list_id", None),
-            ip_addresses=d.get("ip_addresses", None),
-            label=d.get("label", None),
-            list_type=_enum(d, "list_type", ListType),
-        )
-
-
 @dataclass
 class ReplaceResponse:
     def as_dict(self) -> dict:
@@ -4754,31 +4578,6 @@ class RestrictWorkspaceAdminsSetting:
         )
 
 
-@dataclass
-class RevokeTokenRequest:
-    token_id: str
-    """The ID of the token to be revoked."""
-
-    def as_dict(self) -> dict:
-        """Serializes the RevokeTokenRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        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."""
-        return cls(token_id=d.get("token_id", None))
-
-
 @dataclass
 class RevokeTokenResponse:
     def as_dict(self) -> dict:
@@ -5240,1180 +5039,16 @@ class TokenPermissionsDescription:
         )
 
 
-@dataclass
-class TokenPermissionsRequest:
-    access_control_list: Optional[List[TokenAccessControlRequest]] = None
-
-    def as_dict(self) -> dict:
-        """Serializes the TokenPermissionsRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.access_control_list:
-            body["access_control_list"] = [v.as_dict() for v in self.access_control_list]
-        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."""
-        return cls(access_control_list=_repeated_dict(d, "access_control_list", TokenAccessControlRequest))
-
-
-class TokenType(Enum):
-    """The type of token request. As of now, only `AZURE_ACTIVE_DIRECTORY_TOKEN` is supported."""
-
-    ARCLIGHT_AZURE_EXCHANGE_TOKEN = "ARCLIGHT_AZURE_EXCHANGE_TOKEN"
-    ARCLIGHT_AZURE_EXCHANGE_TOKEN_WITH_USER_DELEGATION_KEY = "ARCLIGHT_AZURE_EXCHANGE_TOKEN_WITH_USER_DELEGATION_KEY"
-    ARCLIGHT_MULTI_TENANT_AZURE_EXCHANGE_TOKEN = "ARCLIGHT_MULTI_TENANT_AZURE_EXCHANGE_TOKEN"
-    ARCLIGHT_MULTI_TENANT_AZURE_EXCHANGE_TOKEN_WITH_USER_DELEGATION_KEY = (
-        "ARCLIGHT_MULTI_TENANT_AZURE_EXCHANGE_TOKEN_WITH_USER_DELEGATION_KEY"
-    )
-    AZURE_ACTIVE_DIRECTORY_TOKEN = "AZURE_ACTIVE_DIRECTORY_TOKEN"
-
-
-@dataclass
-class UpdateAccountIpAccessEnableRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: AccountIpAccessEnable
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateAccountIpAccessEnableRequest into a dictionary suitable for use as a JSON request body."""
-        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.as_dict()
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateAccountIpAccessEnableRequest 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]) -> UpdateAccountIpAccessEnableRequest:
-        """Deserializes the UpdateAccountIpAccessEnableRequest from a dictionary."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", AccountIpAccessEnable),
-        )
-
-
-@dataclass
-class UpdateAibiDashboardEmbeddingAccessPolicySettingRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: AibiDashboardEmbeddingAccessPolicySetting
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateAibiDashboardEmbeddingAccessPolicySettingRequest into a dictionary suitable for use as a JSON request body."""
-        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.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."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", AibiDashboardEmbeddingAccessPolicySetting),
-        )
-
-
-@dataclass
-class UpdateAibiDashboardEmbeddingApprovedDomainsSettingRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: AibiDashboardEmbeddingApprovedDomainsSetting
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateAibiDashboardEmbeddingApprovedDomainsSettingRequest into a dictionary suitable for use as a JSON request body."""
-        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.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."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", AibiDashboardEmbeddingApprovedDomainsSetting),
-        )
-
-
-@dataclass
-class UpdateAutomaticClusterUpdateSettingRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: AutomaticClusterUpdateSetting
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateAutomaticClusterUpdateSettingRequest into a dictionary suitable for use as a JSON request body."""
-        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.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."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", AutomaticClusterUpdateSetting),
-        )
-
-
-@dataclass
-class UpdateComplianceSecurityProfileSettingRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: ComplianceSecurityProfileSetting
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateComplianceSecurityProfileSettingRequest into a dictionary suitable for use as a JSON request body."""
-        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.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."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", ComplianceSecurityProfileSetting),
-        )
-
-
-@dataclass
-class UpdateCspEnablementAccountSettingRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: CspEnablementAccountSetting
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateCspEnablementAccountSettingRequest into a dictionary suitable for use as a JSON request body."""
-        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.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."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", CspEnablementAccountSetting),
-        )
-
-
-@dataclass
-class UpdateDashboardEmailSubscriptionsRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: DashboardEmailSubscriptions
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateDashboardEmailSubscriptionsRequest into a dictionary suitable for use as a JSON request body."""
-        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.as_dict()
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateDashboardEmailSubscriptionsRequest 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]) -> UpdateDashboardEmailSubscriptionsRequest:
-        """Deserializes the UpdateDashboardEmailSubscriptionsRequest from a dictionary."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", DashboardEmailSubscriptions),
-        )
-
-
-@dataclass
-class UpdateDefaultNamespaceSettingRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: DefaultNamespaceSetting
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateDefaultNamespaceSettingRequest into a dictionary suitable for use as a JSON request body."""
-        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.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."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", DefaultNamespaceSetting),
-        )
-
-
-@dataclass
-class UpdateDisableLegacyAccessRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: DisableLegacyAccess
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateDisableLegacyAccessRequest into a dictionary suitable for use as a JSON request body."""
-        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.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."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", DisableLegacyAccess),
-        )
-
-
-@dataclass
-class UpdateDisableLegacyDbfsRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: DisableLegacyDbfs
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateDisableLegacyDbfsRequest into a dictionary suitable for use as a JSON request body."""
-        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.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."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", DisableLegacyDbfs),
-        )
-
-
-@dataclass
-class UpdateDisableLegacyFeaturesRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: DisableLegacyFeatures
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateDisableLegacyFeaturesRequest into a dictionary suitable for use as a JSON request body."""
-        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.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."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", DisableLegacyFeatures),
-        )
-
-
-@dataclass
-class UpdateEnableExportNotebookRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: EnableExportNotebook
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateEnableExportNotebookRequest into a dictionary suitable for use as a JSON request body."""
-        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.as_dict()
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateEnableExportNotebookRequest 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]) -> UpdateEnableExportNotebookRequest:
-        """Deserializes the UpdateEnableExportNotebookRequest from a dictionary."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", EnableExportNotebook),
-        )
-
-
-@dataclass
-class UpdateEnableNotebookTableClipboardRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: EnableNotebookTableClipboard
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateEnableNotebookTableClipboardRequest into a dictionary suitable for use as a JSON request body."""
-        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.as_dict()
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateEnableNotebookTableClipboardRequest 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]) -> UpdateEnableNotebookTableClipboardRequest:
-        """Deserializes the UpdateEnableNotebookTableClipboardRequest from a dictionary."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", EnableNotebookTableClipboard),
-        )
-
-
-@dataclass
-class UpdateEnableResultsDownloadingRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: EnableResultsDownloading
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateEnableResultsDownloadingRequest into a dictionary suitable for use as a JSON request body."""
-        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.as_dict()
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateEnableResultsDownloadingRequest 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]) -> UpdateEnableResultsDownloadingRequest:
-        """Deserializes the UpdateEnableResultsDownloadingRequest from a dictionary."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", EnableResultsDownloading),
-        )
-
-
-@dataclass
-class UpdateEnhancedSecurityMonitoringSettingRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: EnhancedSecurityMonitoringSetting
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateEnhancedSecurityMonitoringSettingRequest into a dictionary suitable for use as a JSON request body."""
-        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.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."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", EnhancedSecurityMonitoringSetting),
-        )
-
-
-@dataclass
-class UpdateEsmEnablementAccountSettingRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: EsmEnablementAccountSetting
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateEsmEnablementAccountSettingRequest into a dictionary suitable for use as a JSON request body."""
-        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.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."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", EsmEnablementAccountSetting),
-        )
-
-
-@dataclass
-class UpdateIpAccessList:
-    """Details required to update an IP access list."""
-
-    enabled: Optional[bool] = None
-    """Specifies whether this IP access list is enabled."""
-
-    ip_access_list_id: Optional[str] = None
-    """The ID for the corresponding IP access list"""
-
-    ip_addresses: Optional[List[str]] = None
-
-    label: Optional[str] = None
-    """Label for the IP access list. This **cannot** be empty."""
-
-    list_type: Optional[ListType] = None
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateIpAccessList into a dictionary suitable for use as a JSON request body."""
-        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"] = [v for v in 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.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."""
-        return cls(
-            enabled=d.get("enabled", None),
-            ip_access_list_id=d.get("ip_access_list_id", None),
-            ip_addresses=d.get("ip_addresses", None),
-            label=d.get("label", None),
-            list_type=_enum(d, "list_type", ListType),
-        )
-
-
-@dataclass
-class UpdateLlmProxyPartnerPoweredAccountRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: LlmProxyPartnerPoweredAccount
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateLlmProxyPartnerPoweredAccountRequest into a dictionary suitable for use as a JSON request body."""
-        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.as_dict()
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateLlmProxyPartnerPoweredAccountRequest 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]) -> UpdateLlmProxyPartnerPoweredAccountRequest:
-        """Deserializes the UpdateLlmProxyPartnerPoweredAccountRequest from a dictionary."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", LlmProxyPartnerPoweredAccount),
-        )
-
-
-@dataclass
-class UpdateLlmProxyPartnerPoweredEnforceRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: LlmProxyPartnerPoweredEnforce
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateLlmProxyPartnerPoweredEnforceRequest into a dictionary suitable for use as a JSON request body."""
-        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.as_dict()
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateLlmProxyPartnerPoweredEnforceRequest 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]) -> UpdateLlmProxyPartnerPoweredEnforceRequest:
-        """Deserializes the UpdateLlmProxyPartnerPoweredEnforceRequest from a dictionary."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", LlmProxyPartnerPoweredEnforce),
-        )
-
-
-@dataclass
-class UpdateLlmProxyPartnerPoweredWorkspaceRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: LlmProxyPartnerPoweredWorkspace
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateLlmProxyPartnerPoweredWorkspaceRequest into a dictionary suitable for use as a JSON request body."""
-        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.as_dict()
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateLlmProxyPartnerPoweredWorkspaceRequest 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]) -> UpdateLlmProxyPartnerPoweredWorkspaceRequest:
-        """Deserializes the UpdateLlmProxyPartnerPoweredWorkspaceRequest from a dictionary."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", LlmProxyPartnerPoweredWorkspace),
-        )
-
-
-@dataclass
-class UpdateNotificationDestinationRequest:
-    config: Optional[Config] = None
-    """The configuration for the notification destination. Must wrap EXACTLY one of the nested configs."""
-
-    display_name: Optional[str] = None
-    """The display name for the notification destination."""
-
-    id: Optional[str] = None
-    """UUID identifying notification destination."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateNotificationDestinationRequest into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.config:
-            body["config"] = self.config.as_dict()
-        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
-
-    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."""
-        return cls(
-            config=_from_dict(d, "config", Config), display_name=d.get("display_name", None), id=d.get("id", None)
-        )
-
-
-@dataclass
-class UpdatePersonalComputeSettingRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: PersonalComputeSetting
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdatePersonalComputeSettingRequest into a dictionary suitable for use as a JSON request body."""
-        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.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
+class TokenType(Enum):
+    """The type of token request. As of now, only `AZURE_ACTIVE_DIRECTORY_TOKEN` is supported."""
 
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> UpdatePersonalComputeSettingRequest:
-        """Deserializes the UpdatePersonalComputeSettingRequest from a dictionary."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", PersonalComputeSetting),
-        )
+    ARCLIGHT_AZURE_EXCHANGE_TOKEN = "ARCLIGHT_AZURE_EXCHANGE_TOKEN"
+    ARCLIGHT_AZURE_EXCHANGE_TOKEN_WITH_USER_DELEGATION_KEY = "ARCLIGHT_AZURE_EXCHANGE_TOKEN_WITH_USER_DELEGATION_KEY"
+    ARCLIGHT_MULTI_TENANT_AZURE_EXCHANGE_TOKEN = "ARCLIGHT_MULTI_TENANT_AZURE_EXCHANGE_TOKEN"
+    ARCLIGHT_MULTI_TENANT_AZURE_EXCHANGE_TOKEN_WITH_USER_DELEGATION_KEY = (
+        "ARCLIGHT_MULTI_TENANT_AZURE_EXCHANGE_TOKEN_WITH_USER_DELEGATION_KEY"
+    )
+    AZURE_ACTIVE_DIRECTORY_TOKEN = "AZURE_ACTIVE_DIRECTORY_TOKEN"
 
 
 @dataclass
@@ -6490,110 +5125,6 @@ class UpdateResponse:
         return cls()
 
 
-@dataclass
-class UpdateRestrictWorkspaceAdminsSettingRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: RestrictWorkspaceAdminsSetting
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateRestrictWorkspaceAdminsSettingRequest into a dictionary suitable for use as a JSON request body."""
-        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.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."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", RestrictWorkspaceAdminsSetting),
-        )
-
-
-@dataclass
-class UpdateSqlResultsDownloadRequest:
-    """Details required to update a setting."""
-
-    allow_missing: bool
-    """This should always be set to true for Settings API. Added for AIP compliance."""
-
-    setting: SqlResultsDownload
-
-    field_mask: str
-    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
-    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
-    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
-    as only the entire collection field can be specified. Field names must exactly match the
-    resource field names.
-    
-    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
-    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
-    API changes in the future."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateSqlResultsDownloadRequest into a dictionary suitable for use as a JSON request body."""
-        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.as_dict()
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateSqlResultsDownloadRequest 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]) -> UpdateSqlResultsDownloadRequest:
-        """Deserializes the UpdateSqlResultsDownloadRequest from a dictionary."""
-        return cls(
-            allow_missing=d.get("allow_missing", None),
-            field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", SqlResultsDownload),
-        )
-
-
 WorkspaceConf = Dict[str, str]
 
 
@@ -7584,6 +6115,100 @@ class DefaultNamespaceAPI:
         return DefaultNamespaceSetting.from_dict(res)
 
 
+class DefaultWarehouseIdAPI:
+    """Warehouse to be selected by default for users in this workspace. Covers SQL workloads only and can be
+    overridden by users."""
+
+    def __init__(self, api_client):
+        self._api = api_client
+
+    def delete(self, *, etag: Optional[str] = None) -> DeleteDefaultWarehouseIdResponse:
+        """Reverts the Default Warehouse Id setting to its default value.
+
+        :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:`DeleteDefaultWarehouseIdResponse`
+        """
+
+        query = {}
+        if etag is not None:
+            query["etag"] = etag
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do(
+            "DELETE", "/api/2.0/settings/types/default_warehouse_id/names/default", query=query, headers=headers
+        )
+        return DeleteDefaultWarehouseIdResponse.from_dict(res)
+
+    def get(self, *, etag: Optional[str] = None) -> DefaultWarehouseId:
+        """Gets the Default Warehouse Id setting.
+
+        :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:`DefaultWarehouseId`
+        """
+
+        query = {}
+        if etag is not None:
+            query["etag"] = etag
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do(
+            "GET", "/api/2.0/settings/types/default_warehouse_id/names/default", query=query, headers=headers
+        )
+        return DefaultWarehouseId.from_dict(res)
+
+    def update(self, allow_missing: bool, setting: DefaultWarehouseId, field_mask: str) -> DefaultWarehouseId:
+        """Updates the Default Warehouse Id setting.
+
+        :param allow_missing: bool
+          This should always be set to true for Settings API. Added for AIP compliance.
+        :param setting: :class:`DefaultWarehouseId`
+        :param field_mask: str
+          The field mask must be a single string, with multiple fields separated by commas (no spaces). The
+          field path is relative to the resource object, using a dot (`.`) to navigate sub-fields (e.g.,
+          `author.given_name`). Specification of elements in sequence or map fields is not allowed, as only
+          the entire collection field can be specified. Field names must exactly match the resource field
+          names.
+
+          A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
+          fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the API
+          changes in the future.
+
+        :returns: :class:`DefaultWarehouseId`
+        """
+        body = {}
+        if allow_missing is not None:
+            body["allow_missing"] = allow_missing
+        if field_mask is not None:
+            body["field_mask"] = field_mask
+        if setting is not None:
+            body["setting"] = setting.as_dict()
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do(
+            "PATCH", "/api/2.0/settings/types/default_warehouse_id/names/default", body=body, headers=headers
+        )
+        return DefaultWarehouseId.from_dict(res)
+
+
 class DisableLegacyAccessAPI:
     """'Disabling legacy access' has the following impacts:
 
@@ -9527,6 +8152,7 @@ class SettingsAPI:
         self._compliance_security_profile = ComplianceSecurityProfileAPI(self._api)
         self._dashboard_email_subscriptions = DashboardEmailSubscriptionsAPI(self._api)
         self._default_namespace = DefaultNamespaceAPI(self._api)
+        self._default_warehouse_id = DefaultWarehouseIdAPI(self._api)
         self._disable_legacy_access = DisableLegacyAccessAPI(self._api)
         self._disable_legacy_dbfs = DisableLegacyDbfsAPI(self._api)
         self._enable_export_notebook = EnableExportNotebookAPI(self._api)
@@ -9567,6 +8193,11 @@ class SettingsAPI:
         """The default namespace setting API allows users to configure the default namespace for a Databricks workspace."""
         return self._default_namespace
 
+    @property
+    def default_warehouse_id(self) -> DefaultWarehouseIdAPI:
+        """Warehouse to be selected by default for users in this workspace."""
+        return self._default_warehouse_id
+
     @property
     def disable_legacy_access(self) -> DisableLegacyAccessAPI:
         """'Disabling legacy access' has the following impacts: 1."""