databricks-sdk 0.55.0__py3-none-any.whl → 0.57.0__py3-none-any.whl

databricks/sdk/service/settings.py

@@ -963,31 +963,45 @@ class CreatePrivateEndpointRule:
     """Properties of the new private endpoint rule. Note that you must approve the endpoint in Azure
     portal after initialization."""
 
-    resource_id: str
-    """The Azure resource ID of the target resource."""
-
     domain_names: Optional[List[str]] = None
-    """Only used by private endpoints to customer-managed resources.
+    """Only used by private endpoints to customer-managed private endpoint services.
     
     Domain names of target private link service. When updating this field, the full list of target
     domain_names must be specified."""
 
+    endpoint_service: Optional[str] = None
+    """The full target AWS endpoint service name that connects to the destination resources of the
+    private endpoint."""
+
     group_id: Optional[str] = None
-    """Only used by private endpoints to Azure first-party services. Enum: blob | dfs | sqlServer |
-    mysqlServer
+    """Not used by customer-managed private endpoint services.
     
     The sub-resource type (group ID) of the target resource. Note that to connect to workspace root
     storage (root DBFS), you need two endpoints, one for blob and one for dfs."""
 
+    resource_id: Optional[str] = None
+    """The Azure resource ID of the target resource."""
+
+    resource_names: Optional[List[str]] = None
+    """Only used by private endpoints towards AWS S3 service.
+    
+    The globally unique S3 bucket names that will be accessed via the VPC endpoint. The bucket names
+    must be in the same region as the NCC/endpoint service. When updating this field, we perform
+    full update on this field. Please ensure a full list of desired resource_names is provided."""
+
     def as_dict(self) -> dict:
         """Serializes the CreatePrivateEndpointRule into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.domain_names:
             body["domain_names"] = [v for v in self.domain_names]
+        if self.endpoint_service is not None:
+            body["endpoint_service"] = self.endpoint_service
         if self.group_id is not None:
             body["group_id"] = self.group_id
         if self.resource_id is not None:
             body["resource_id"] = self.resource_id
+        if self.resource_names:
+            body["resource_names"] = [v for v in self.resource_names]
         return body
 
     def as_shallow_dict(self) -> dict:
@@ -995,10 +1009,14 @@ class CreatePrivateEndpointRule:
         body = {}
         if self.domain_names:
             body["domain_names"] = self.domain_names
+        if self.endpoint_service is not None:
+            body["endpoint_service"] = self.endpoint_service
         if self.group_id is not None:
             body["group_id"] = self.group_id
         if self.resource_id is not None:
             body["resource_id"] = self.resource_id
+        if self.resource_names:
+            body["resource_names"] = self.resource_names
         return body
 
     @classmethod
@@ -1006,8 +1024,10 @@ class CreatePrivateEndpointRule:
         """Deserializes the CreatePrivateEndpointRule from a dictionary."""
         return cls(
             domain_names=d.get("domain_names", None),
+            endpoint_service=d.get("endpoint_service", None),
             group_id=d.get("group_id", None),
             resource_id=d.get("resource_id", None),
+            resource_names=d.get("resource_names", None),
         )
 
 
@@ -1166,6 +1186,219 @@ class CspEnablementAccountSetting:
         )
 
 
+@dataclass
+class CustomerFacingNetworkConnectivityConfigAwsPrivateEndpointRule:
+    """Properties of the new private endpoint rule. Note that for private endpoints towards a VPC
+    endpoint service behind a customer-managed NLB, you must approve the endpoint in AWS console
+    after initialization."""
+
+    account_id: Optional[str] = None
+    """Databricks account ID. You can find your account ID from the Accounts Console."""
+
+    connection_state: Optional[
+        CustomerFacingNetworkConnectivityConfigAwsPrivateEndpointRulePrivateLinkConnectionState
+    ] = None
+    """The current status of this private endpoint. The private endpoint rules are effective only if
+    the connection state is ESTABLISHED. Remember that you must approve new endpoints on your
+    resources in the AWS console before they take effect. The possible values are: - PENDING: The
+    endpoint has been created and pending approval. - ESTABLISHED: The endpoint has been approved
+    and is ready to use in your serverless compute resources. - REJECTED: Connection was rejected by
+    the private link resource owner. - DISCONNECTED: Connection was removed by the private link
+    resource owner, the private endpoint becomes informative and should be deleted for clean-up. -
+    EXPIRED: If the endpoint is created but not approved in 14 days, it is EXPIRED."""
+
+    creation_time: Optional[int] = None
+    """Time in epoch milliseconds when this object was created."""
+
+    deactivated: Optional[bool] = None
+    """Whether this private endpoint is deactivated."""
+
+    deactivated_at: Optional[int] = None
+    """Time in epoch milliseconds when this object was deactivated."""
+
+    domain_names: Optional[List[str]] = None
+    """Only used by private endpoints towards a VPC endpoint service for customer-managed VPC endpoint
+    service.
+    
+    The target AWS resource FQDNs accessible via the VPC endpoint service. When updating this field,
+    we perform full update on this field. Please ensure a full list of desired domain_names is
+    provided."""
+
+    enabled: Optional[bool] = None
+    """Only used by private endpoints towards an AWS S3 service.
+    
+    Update this field to activate/deactivate this private endpoint to allow egress access from
+    serverless compute resources."""
+
+    endpoint_service: Optional[str] = None
+    """The full target AWS endpoint service name that connects to the destination resources of the
+    private endpoint."""
+
+    network_connectivity_config_id: Optional[str] = None
+    """The ID of a network connectivity configuration, which is the parent resource of this private
+    endpoint rule object."""
+
+    resource_names: Optional[List[str]] = None
+    """Only used by private endpoints towards AWS S3 service.
+    
+    The globally unique S3 bucket names that will be accessed via the VPC endpoint. The bucket names
+    must be in the same region as the NCC/endpoint service. When updating this field, we perform
+    full update on this field. Please ensure a full list of desired resource_names is provided."""
+
+    rule_id: Optional[str] = None
+    """The ID of a private endpoint rule."""
+
+    updated_time: Optional[int] = None
+    """Time in epoch milliseconds when this object was updated."""
+
+    vpc_endpoint_id: Optional[str] = None
+    """The AWS VPC endpoint ID. You can use this ID to identify VPC endpoint created by Databricks."""
+
+    def as_dict(self) -> dict:
+        """Serializes the CustomerFacingNetworkConnectivityConfigAwsPrivateEndpointRule into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.account_id is not None:
+            body["account_id"] = self.account_id
+        if self.connection_state is not None:
+            body["connection_state"] = self.connection_state.value
+        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.domain_names:
+            body["domain_names"] = [v for v in self.domain_names]
+        if self.enabled is not None:
+            body["enabled"] = self.enabled
+        if self.endpoint_service is not None:
+            body["endpoint_service"] = self.endpoint_service
+        if self.network_connectivity_config_id is not None:
+            body["network_connectivity_config_id"] = self.network_connectivity_config_id
+        if self.resource_names:
+            body["resource_names"] = [v for v in self.resource_names]
+        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
+        if self.vpc_endpoint_id is not None:
+            body["vpc_endpoint_id"] = self.vpc_endpoint_id
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CustomerFacingNetworkConnectivityConfigAwsPrivateEndpointRule into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.account_id is not None:
+            body["account_id"] = self.account_id
+        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.domain_names:
+            body["domain_names"] = self.domain_names
+        if self.enabled is not None:
+            body["enabled"] = self.enabled
+        if self.endpoint_service is not None:
+            body["endpoint_service"] = self.endpoint_service
+        if self.network_connectivity_config_id is not None:
+            body["network_connectivity_config_id"] = self.network_connectivity_config_id
+        if self.resource_names:
+            body["resource_names"] = self.resource_names
+        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
+        if self.vpc_endpoint_id is not None:
+            body["vpc_endpoint_id"] = self.vpc_endpoint_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> CustomerFacingNetworkConnectivityConfigAwsPrivateEndpointRule:
+        """Deserializes the CustomerFacingNetworkConnectivityConfigAwsPrivateEndpointRule from a dictionary."""
+        return cls(
+            account_id=d.get("account_id", None),
+            connection_state=_enum(
+                d,
+                "connection_state",
+                CustomerFacingNetworkConnectivityConfigAwsPrivateEndpointRulePrivateLinkConnectionState,
+            ),
+            creation_time=d.get("creation_time", None),
+            deactivated=d.get("deactivated", None),
+            deactivated_at=d.get("deactivated_at", None),
+            domain_names=d.get("domain_names", None),
+            enabled=d.get("enabled", None),
+            endpoint_service=d.get("endpoint_service", None),
+            network_connectivity_config_id=d.get("network_connectivity_config_id", None),
+            resource_names=d.get("resource_names", None),
+            rule_id=d.get("rule_id", None),
+            updated_time=d.get("updated_time", None),
+            vpc_endpoint_id=d.get("vpc_endpoint_id", None),
+        )
+
+
+class CustomerFacingNetworkConnectivityConfigAwsPrivateEndpointRulePrivateLinkConnectionState(Enum):
+
+    DISCONNECTED = "DISCONNECTED"
+    ESTABLISHED = "ESTABLISHED"
+    EXPIRED = "EXPIRED"
+    PENDING = "PENDING"
+    REJECTED = "REJECTED"
+
+
+@dataclass
+class DashboardEmailSubscriptions:
+    boolean_val: BooleanMessage
+
+    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 DashboardEmailSubscriptions into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.boolean_val:
+            body["boolean_val"] = self.boolean_val.as_dict()
+        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
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DashboardEmailSubscriptions into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.boolean_val:
+            body["boolean_val"] = self.boolean_val
+        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]) -> DashboardEmailSubscriptions:
+        """Deserializes the DashboardEmailSubscriptions from a dictionary."""
+        return cls(
+            boolean_val=_from_dict(d, "boolean_val", BooleanMessage),
+            etag=d.get("etag", None),
+            setting_name=d.get("setting_name", None),
+        )
+
+
 @dataclass
 class DefaultNamespaceSetting:
     """This represents the setting configuration for the default namespace in the Databricks workspace.
@@ -1320,6 +1553,38 @@ class DeleteAibiDashboardEmbeddingApprovedDomainsSettingResponse:
         return cls(etag=d.get("etag", None))
 
 
+@dataclass
+class DeleteDashboardEmailSubscriptionsResponse:
+    """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 DeleteDashboardEmailSubscriptionsResponse 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 DeleteDashboardEmailSubscriptionsResponse 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]) -> DeleteDashboardEmailSubscriptionsResponse:
+        """Deserializes the DeleteDashboardEmailSubscriptionsResponse from a dictionary."""
+        return cls(etag=d.get("etag", None))
+
+
 @dataclass
 class DeleteDefaultNamespaceSettingResponse:
     """The etag is returned."""
@@ -1598,6 +1863,38 @@ class DeleteRestrictWorkspaceAdminsSettingResponse:
         return cls(etag=d.get("etag", None))
 
 
+@dataclass
+class DeleteSqlResultsDownloadResponse:
+    """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 DeleteSqlResultsDownloadResponse 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 DeleteSqlResultsDownloadResponse 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]) -> DeleteSqlResultsDownloadResponse:
+        """Deserializes the DeleteSqlResultsDownloadResponse from a dictionary."""
+        return cls(etag=d.get("etag", None))
+
+
 class DestinationType(Enum):
 
     EMAIL = "EMAIL"
@@ -2247,7 +2544,6 @@ class EgressNetworkPolicyNetworkAccessPolicyStorageDestination:
     bucket_name: Optional[str] = None
 
     region: Optional[str] = None
-    """The region of the S3 bucket."""
 
     storage_destination_type: Optional[
         EgressNetworkPolicyNetworkAccessPolicyStorageDestinationStorageDestinationType
@@ -3073,43 +3369,6 @@ class ListIpAccessListResponse:
         return cls(ip_access_lists=_repeated_dict(d, "ip_access_lists", IpAccessListInfo))
 
 
-@dataclass
-class ListNccAzurePrivateEndpointRulesResponse:
-    """The private endpoint rule list was successfully retrieved."""
-
-    items: Optional[List[NccAzurePrivateEndpointRule]] = None
-
-    next_page_token: Optional[str] = None
-    """A token that can be used to get the next page of results. If null, there are no more results to
-    show."""
-
-    def as_dict(self) -> dict:
-        """Serializes the ListNccAzurePrivateEndpointRulesResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.items:
-            body["items"] = [v.as_dict() for v in self.items]
-        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."""
-        return cls(
-            items=_repeated_dict(d, "items", NccAzurePrivateEndpointRule),
-            next_page_token=d.get("next_page_token", None),
-        )
-
-
 @dataclass
 class ListNetworkConnectivityConfigurationsResponse:
     """The network connectivity configuration list was successfully retrieved."""
@@ -3259,6 +3518,42 @@ class ListNotificationDestinationsResult:
         )
 
 
+@dataclass
+class ListPrivateEndpointRulesResponse:
+    """The private endpoint rule list was successfully retrieved."""
+
+    items: Optional[List[NccPrivateEndpointRule]] = None
+
+    next_page_token: Optional[str] = None
+    """A token that can be used to get the next page of results. If null, there are no more results to
+    show."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ListPrivateEndpointRulesResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.items:
+            body["items"] = [v.as_dict() for v in self.items]
+        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 ListPrivateEndpointRulesResponse 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]) -> ListPrivateEndpointRulesResponse:
+        """Deserializes the ListPrivateEndpointRulesResponse from a dictionary."""
+        return cls(
+            items=_repeated_dict(d, "items", NccPrivateEndpointRule), next_page_token=d.get("next_page_token", None)
+        )
+
+
 @dataclass
 class ListPublicTokensResponse:
     token_infos: Optional[List[PublicTokenInfo]] = None
@@ -3558,7 +3853,7 @@ class NccAzurePrivateEndpointRule:
     """Time in epoch milliseconds when this object was deactivated."""
 
     domain_names: Optional[List[str]] = None
-    """Only used by private endpoints to customer-managed resources.
+    """Not used by customer-managed private endpoint services.
     
     Domain names of target private link service. When updating this field, the full list of target
     domain_names must be specified."""
@@ -3567,8 +3862,7 @@ class NccAzurePrivateEndpointRule:
     """The name of the Azure private endpoint resource."""
 
     group_id: Optional[str] = None
-    """Only used by private endpoints to Azure first-party services. Enum: blob | dfs | sqlServer |
-    mysqlServer
+    """Only used by private endpoints to Azure first-party services.
     
     The sub-resource type (group ID) of the target resource. Note that to connect to workspace root
     storage (root DBFS), you need two endpoints, one for blob and one for dfs."""
@@ -3783,49 +4077,240 @@ class NccEgressDefaultRules:
             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."""
-        return cls(
-            aws_stable_ip_rule=_from_dict(d, "aws_stable_ip_rule", NccAwsStableIpRule),
-            azure_service_endpoint_rule=_from_dict(d, "azure_service_endpoint_rule", NccAzureServiceEndpointRule),
-        )
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> NccEgressDefaultRules:
+        """Deserializes the NccEgressDefaultRules from a dictionary."""
+        return cls(
+            aws_stable_ip_rule=_from_dict(d, "aws_stable_ip_rule", NccAwsStableIpRule),
+            azure_service_endpoint_rule=_from_dict(d, "azure_service_endpoint_rule", NccAzureServiceEndpointRule),
+        )
+
+
+@dataclass
+class NccEgressTargetRules:
+    """Target rule controls the egress rules that are dedicated to specific resources."""
+
+    aws_private_endpoint_rules: Optional[List[CustomerFacingNetworkConnectivityConfigAwsPrivateEndpointRule]] = None
+    """AWS private endpoint rule controls the AWS private endpoint based egress rules."""
+
+    azure_private_endpoint_rules: Optional[List[NccAzurePrivateEndpointRule]] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the NccEgressTargetRules into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.aws_private_endpoint_rules:
+            body["aws_private_endpoint_rules"] = [v.as_dict() for v in self.aws_private_endpoint_rules]
+        if self.azure_private_endpoint_rules:
+            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.aws_private_endpoint_rules:
+            body["aws_private_endpoint_rules"] = self.aws_private_endpoint_rules
+        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."""
+        return cls(
+            aws_private_endpoint_rules=_repeated_dict(
+                d, "aws_private_endpoint_rules", CustomerFacingNetworkConnectivityConfigAwsPrivateEndpointRule
+            ),
+            azure_private_endpoint_rules=_repeated_dict(d, "azure_private_endpoint_rules", NccAzurePrivateEndpointRule),
+        )
+
+
+@dataclass
+class NccPrivateEndpointRule:
+    """Properties of the new private endpoint rule. Note that you must approve the endpoint in Azure
+    portal after initialization."""
+
+    account_id: Optional[str] = None
+    """Databricks account ID. You can find your account ID from the Accounts Console."""
+
+    connection_state: Optional[NccPrivateEndpointRulePrivateLinkConnectionState] = None
+    """The current status of this private endpoint. The private endpoint rules are effective only if
+    the connection state is ESTABLISHED. Remember that you must approve new endpoints on your
+    resources in the Cloud console before they take effect. The possible values are: - PENDING: The
+    endpoint has been created and pending approval. - ESTABLISHED: The endpoint has been approved
+    and is ready to use in your serverless compute resources. - REJECTED: Connection was rejected by
+    the private link resource owner. - DISCONNECTED: Connection was removed by the private link
+    resource owner, the private endpoint becomes informative and should be deleted for clean-up. -
+    EXPIRED: If the endpoint was created but not approved in 14 days, it will be EXPIRED."""
+
+    creation_time: Optional[int] = None
+    """Time in epoch milliseconds when this object was created."""
+
+    deactivated: Optional[bool] = None
+    """Whether this private endpoint is deactivated."""
+
+    deactivated_at: Optional[int] = None
+    """Time in epoch milliseconds when this object was deactivated."""
+
+    domain_names: Optional[List[str]] = None
+    """Only used by private endpoints to customer-managed private endpoint services.
+    
+    Domain names of target private link service. When updating this field, the full list of target
+    domain_names must be specified."""
+
+    enabled: Optional[bool] = None
+    """Only used by private endpoints towards an AWS S3 service.
+    
+    Update this field to activate/deactivate this private endpoint to allow egress access from
+    serverless compute resources."""
+
+    endpoint_name: Optional[str] = None
+    """The name of the Azure private endpoint resource."""
+
+    endpoint_service: Optional[str] = None
+    """The full target AWS endpoint service name that connects to the destination resources of the
+    private endpoint."""
+
+    group_id: Optional[str] = None
+    """Not used by customer-managed private endpoint services.
+    
+    The sub-resource type (group ID) of the target resource. Note that to connect to workspace root
+    storage (root DBFS), you need two endpoints, one for blob and one for dfs."""
+
+    network_connectivity_config_id: Optional[str] = None
+    """The ID of a network connectivity configuration, which is the parent resource of this private
+    endpoint rule object."""
 
+    resource_id: Optional[str] = None
+    """The Azure resource ID of the target resource."""
 
-@dataclass
-class NccEgressTargetRules:
-    """Target rule controls the egress rules that are dedicated to specific resources."""
+    resource_names: Optional[List[str]] = None
+    """Only used by private endpoints towards AWS S3 service.
+    
+    The globally unique S3 bucket names that will be accessed via the VPC endpoint. The bucket names
+    must be in the same region as the NCC/endpoint service. When updating this field, we perform
+    full update on this field. Please ensure a full list of desired resource_names is provided."""
 
-    azure_private_endpoint_rules: Optional[List[NccAzurePrivateEndpointRule]] = None
+    rule_id: Optional[str] = None
+    """The ID of a private endpoint rule."""
+
+    updated_time: Optional[int] = None
+    """Time in epoch milliseconds when this object was updated."""
+
+    vpc_endpoint_id: Optional[str] = None
+    """The AWS VPC endpoint ID. You can use this ID to identify the VPC endpoint created by Databricks."""
 
     def as_dict(self) -> dict:
-        """Serializes the NccEgressTargetRules into a dictionary suitable for use as a JSON request body."""
+        """Serializes the NccPrivateEndpointRule into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.azure_private_endpoint_rules:
-            body["azure_private_endpoint_rules"] = [v.as_dict() for v in self.azure_private_endpoint_rules]
+        if self.account_id is not None:
+            body["account_id"] = self.account_id
+        if self.connection_state is not None:
+            body["connection_state"] = self.connection_state.value
+        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.domain_names:
+            body["domain_names"] = [v for v in self.domain_names]
+        if self.enabled is not None:
+            body["enabled"] = self.enabled
+        if self.endpoint_name is not None:
+            body["endpoint_name"] = self.endpoint_name
+        if self.endpoint_service is not None:
+            body["endpoint_service"] = self.endpoint_service
+        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
+        if self.resource_names:
+            body["resource_names"] = [v for v in self.resource_names]
+        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
+        if self.vpc_endpoint_id is not None:
+            body["vpc_endpoint_id"] = self.vpc_endpoint_id
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the NccEgressTargetRules into a shallow dictionary of its immediate attributes."""
+        """Serializes the NccPrivateEndpointRule 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
+        if self.account_id is not None:
+            body["account_id"] = self.account_id
+        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.domain_names:
+            body["domain_names"] = self.domain_names
+        if self.enabled is not None:
+            body["enabled"] = self.enabled
+        if self.endpoint_name is not None:
+            body["endpoint_name"] = self.endpoint_name
+        if self.endpoint_service is not None:
+            body["endpoint_service"] = self.endpoint_service
+        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
+        if self.resource_names:
+            body["resource_names"] = self.resource_names
+        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
+        if self.vpc_endpoint_id is not None:
+            body["vpc_endpoint_id"] = self.vpc_endpoint_id
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> NccEgressTargetRules:
-        """Deserializes the NccEgressTargetRules from a dictionary."""
+    def from_dict(cls, d: Dict[str, Any]) -> NccPrivateEndpointRule:
+        """Deserializes the NccPrivateEndpointRule from a dictionary."""
         return cls(
-            azure_private_endpoint_rules=_repeated_dict(d, "azure_private_endpoint_rules", NccAzurePrivateEndpointRule)
+            account_id=d.get("account_id", None),
+            connection_state=_enum(d, "connection_state", NccPrivateEndpointRulePrivateLinkConnectionState),
+            creation_time=d.get("creation_time", None),
+            deactivated=d.get("deactivated", None),
+            deactivated_at=d.get("deactivated_at", None),
+            domain_names=d.get("domain_names", None),
+            enabled=d.get("enabled", None),
+            endpoint_name=d.get("endpoint_name", None),
+            endpoint_service=d.get("endpoint_service", None),
+            group_id=d.get("group_id", None),
+            network_connectivity_config_id=d.get("network_connectivity_config_id", None),
+            resource_id=d.get("resource_id", None),
+            resource_names=d.get("resource_names", None),
+            rule_id=d.get("rule_id", None),
+            updated_time=d.get("updated_time", None),
+            vpc_endpoint_id=d.get("vpc_endpoint_id", None),
         )
 
 
+class NccPrivateEndpointRulePrivateLinkConnectionState(Enum):
+
+    DISCONNECTED = "DISCONNECTED"
+    ESTABLISHED = "ESTABLISHED"
+    EXPIRED = "EXPIRED"
+    PENDING = "PENDING"
+    REJECTED = "REJECTED"
+
+
 @dataclass
 class NetworkConnectivityConfiguration:
     """Properties of the new network connectivity configuration."""
 
     account_id: Optional[str] = None
-    """The Databricks account ID that hosts the credential."""
+    """Your Databricks account ID. You can find your account ID in your Databricks accounts console."""
 
     creation_time: Optional[int] = None
     """Time in epoch milliseconds when this object was created."""
@@ -4440,6 +4925,56 @@ class SlackConfig:
         return cls(url=d.get("url", None), url_set=d.get("url_set", None))
 
 
+@dataclass
+class SqlResultsDownload:
+    boolean_val: BooleanMessage
+
+    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 SqlResultsDownload into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.boolean_val:
+            body["boolean_val"] = self.boolean_val.as_dict()
+        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
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the SqlResultsDownload into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.boolean_val:
+            body["boolean_val"] = self.boolean_val
+        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]) -> SqlResultsDownload:
+        """Deserializes the SqlResultsDownload from a dictionary."""
+        return cls(
+            boolean_val=_from_dict(d, "boolean_val", BooleanMessage),
+            etag=d.get("etag", None),
+            setting_name=d.get("setting_name", None),
+        )
+
+
 @dataclass
 class StringMessage:
     value: Optional[str] = None
@@ -5134,6 +5669,58 @@ class UpdateCspEnablementAccountSettingRequest:
         )
 
 
+@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."""
@@ -5927,16 +6514,33 @@ class UpdatePrivateEndpointRule:
     portal after initialization."""
 
     domain_names: Optional[List[str]] = None
-    """Only used by private endpoints to customer-managed resources.
+    """Only used by private endpoints to customer-managed private endpoint services.
     
     Domain names of target private link service. When updating this field, the full list of target
     domain_names must be specified."""
 
+    enabled: Optional[bool] = None
+    """Only used by private endpoints towards an AWS S3 service.
+    
+    Update this field to activate/deactivate this private endpoint to allow egress access from
+    serverless compute resources."""
+
+    resource_names: Optional[List[str]] = None
+    """Only used by private endpoints towards AWS S3 service.
+    
+    The globally unique S3 bucket names that will be accessed via the VPC endpoint. The bucket names
+    must be in the same region as the NCC/endpoint service. When updating this field, we perform
+    full update on this field. Please ensure a full list of desired resource_names is provided."""
+
     def as_dict(self) -> dict:
         """Serializes the UpdatePrivateEndpointRule into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.domain_names:
             body["domain_names"] = [v for v in self.domain_names]
+        if self.enabled is not None:
+            body["enabled"] = self.enabled
+        if self.resource_names:
+            body["resource_names"] = [v for v in self.resource_names]
         return body
 
     def as_shallow_dict(self) -> dict:
@@ -5944,12 +6548,20 @@ class UpdatePrivateEndpointRule:
         body = {}
         if self.domain_names:
             body["domain_names"] = self.domain_names
+        if self.enabled is not None:
+            body["enabled"] = self.enabled
+        if self.resource_names:
+            body["resource_names"] = self.resource_names
         return body
 
     @classmethod
     def from_dict(cls, d: Dict[str, Any]) -> UpdatePrivateEndpointRule:
         """Deserializes the UpdatePrivateEndpointRule from a dictionary."""
-        return cls(domain_names=d.get("domain_names", None))
+        return cls(
+            domain_names=d.get("domain_names", None),
+            enabled=d.get("enabled", None),
+            resource_names=d.get("resource_names", None),
+        )
 
 
 @dataclass
@@ -6022,6 +6634,58 @@ class UpdateRestrictWorkspaceAdminsSettingRequest:
         )
 
 
+@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]
 
 
@@ -6085,9 +6749,7 @@ class AccountIpAccessListsAPI:
     def create(
         self, label: str, list_type: ListType, *, ip_addresses: Optional[List[str]] = None
     ) -> CreateIpAccessListResponse:
-        """Create access list.
-
-        Creates an IP access list for the account.
+        """Creates an IP access list for the account.
 
         A list can be an allow list or a block list. See the top of this file for a description of how the
         server treats allow lists and block lists at runtime.
@@ -6130,9 +6792,7 @@ class AccountIpAccessListsAPI:
         return CreateIpAccessListResponse.from_dict(res)
 
     def delete(self, ip_access_list_id: str):
-        """Delete access list.
-
-        Deletes an IP access list, specified by its list ID.
+        """Deletes an IP access list, specified by its list ID.
 
         :param ip_access_list_id: str
           The ID for the corresponding IP access list
@@ -6147,9 +6807,7 @@ class AccountIpAccessListsAPI:
         )
 
     def get(self, ip_access_list_id: str) -> GetIpAccessListResponse:
-        """Get IP access list.
-
-        Gets an IP access list, specified by its list ID.
+        """Gets an IP access list, specified by its list ID.
 
         :param ip_access_list_id: str
           The ID for the corresponding IP access list
@@ -6167,9 +6825,7 @@ class AccountIpAccessListsAPI:
         return GetIpAccessListResponse.from_dict(res)
 
     def list(self) -> Iterator[IpAccessListInfo]:
-        """Get access lists.
-
-        Gets all IP access lists for the specified account.
+        """Gets all IP access lists for the specified account.
 
         :returns: Iterator over :class:`IpAccessListInfo`
         """
@@ -6191,9 +6847,7 @@ class AccountIpAccessListsAPI:
         *,
         ip_addresses: Optional[List[str]] = None,
     ):
-        """Replace access list.
-
-        Replaces an IP access list, specified by its ID.
+        """Replaces an IP access list, specified by its ID.
 
         A list can include allow lists and block lists. See the top of this file for a description of how the
         server treats allow lists and block lists at run time. When replacing an IP access list: * For all
@@ -6247,9 +6901,7 @@ class AccountIpAccessListsAPI:
         label: Optional[str] = None,
         list_type: Optional[ListType] = None,
     ):
-        """Update access list.
-
-        Updates an existing IP access list, specified by its ID.
+        """Updates an existing IP access list, specified by its ID.
 
         A list can include allow lists and block lists. See the top of this file for a description of how the
         server treats allow lists and block lists at run time.
@@ -6357,9 +7009,7 @@ class AibiDashboardEmbeddingAccessPolicyAPI:
         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.
+        """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
@@ -6387,9 +7037,7 @@ class AibiDashboardEmbeddingAccessPolicyAPI:
         return DeleteAibiDashboardEmbeddingAccessPolicySettingResponse.from_dict(res)
 
     def get(self, *, etag: Optional[str] = None) -> AibiDashboardEmbeddingAccessPolicySetting:
-        """Retrieve the AI/BI dashboard embedding access policy.
-
-        Retrieves the AI/BI dashboard embedding access policy. The default setting is ALLOW_APPROVED_DOMAINS,
+        """Retrieves the AI/BI dashboard embedding access policy. The default setting is ALLOW_APPROVED_DOMAINS,
         permitting AI/BI dashboards to be embedded on approved domains.
 
         :param etag: str (optional)
@@ -6417,9 +7065,7 @@ class AibiDashboardEmbeddingAccessPolicyAPI:
     def update(
         self, allow_missing: bool, setting: AibiDashboardEmbeddingAccessPolicySetting, field_mask: str
     ) -> AibiDashboardEmbeddingAccessPolicySetting:
-        """Update the AI/BI dashboard embedding access policy.
-
-        Updates the AI/BI dashboard embedding access policy at the workspace level.
+        """Updates the AI/BI dashboard embedding access policy at the workspace level.
 
         :param allow_missing: bool
           This should always be set to true for Settings API. Added for AIP compliance.
@@ -6463,9 +7109,7 @@ class AibiDashboardEmbeddingApprovedDomainsAPI:
         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
+        """Delete the list of domains approved to host embedded AI/BI dashboards, reverting back to the default
         empty list.
 
         :param etag: str (optional)
@@ -6494,9 +7138,7 @@ class AibiDashboardEmbeddingApprovedDomainsAPI:
         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.
-
-        Retrieves the list of domains approved to host embedded AI/BI dashboards.
+        """Retrieves the list of domains approved to host embedded AI/BI dashboards.
 
         :param etag: str (optional)
           etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
@@ -6526,9 +7168,7 @@ class AibiDashboardEmbeddingApprovedDomainsAPI:
     def update(
         self, allow_missing: bool, setting: AibiDashboardEmbeddingApprovedDomainsSetting, field_mask: str
     ) -> AibiDashboardEmbeddingApprovedDomainsSetting:
-        """Update the list of domains approved to host embedded AI/BI dashboards.
-
-        Updates the list of domains approved to host embedded AI/BI dashboards. This update will fail if the
+        """Updates the list of domains approved to host embedded AI/BI dashboards. This update will fail if the
         current workspace access policy is not ALLOW_APPROVED_DOMAINS.
 
         :param allow_missing: bool
@@ -6576,9 +7216,7 @@ class AutomaticClusterUpdateAPI:
         self._api = api_client
 
     def get(self, *, etag: Optional[str] = None) -> AutomaticClusterUpdateSetting:
-        """Get the automatic cluster update setting.
-
-        Gets the automatic cluster update setting.
+        """Gets the automatic cluster update setting.
 
         :param etag: str (optional)
           etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
@@ -6605,9 +7243,7 @@ class AutomaticClusterUpdateAPI:
     def update(
         self, allow_missing: bool, setting: AutomaticClusterUpdateSetting, field_mask: str
     ) -> AutomaticClusterUpdateSetting:
-        """Update the automatic cluster update setting.
-
-        Updates the automatic cluster update setting for the workspace. A fresh etag needs to be provided in
+        """Updates the automatic cluster update setting for the workspace. A fresh etag needs to be provided in
         `PATCH` requests (as part of the setting field). The etag can be retrieved by making a `GET` request
         before the `PATCH` request. If the setting is updated concurrently, `PATCH` fails with 409 and the
         request must be retried by using the fresh etag in the 409 response.
@@ -6656,9 +7292,7 @@ class ComplianceSecurityProfileAPI:
         self._api = api_client
 
     def get(self, *, etag: Optional[str] = None) -> ComplianceSecurityProfileSetting:
-        """Get the compliance security profile setting.
-
-        Gets the compliance security profile setting.
+        """Gets the compliance security profile setting.
 
         :param etag: str (optional)
           etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
@@ -6685,9 +7319,7 @@ class ComplianceSecurityProfileAPI:
     def update(
         self, allow_missing: bool, setting: ComplianceSecurityProfileSetting, field_mask: str
     ) -> ComplianceSecurityProfileSetting:
-        """Update the compliance security profile setting.
-
-        Updates the compliance security profile setting for the workspace. A fresh etag needs to be provided
+        """Updates the compliance security profile setting for the workspace. A fresh etag needs to be provided
         in `PATCH` requests (as part of the setting field). The etag can be retrieved by making a `GET`
         request before the `PATCH` request. If the setting is updated concurrently, `PATCH` fails with 409 and
         the request must be retried by using the fresh etag in the 409 response.
@@ -6736,9 +7368,7 @@ class CredentialsManagerAPI:
     def exchange_token(
         self, partition_id: PartitionId, token_type: List[TokenType], scopes: List[str]
     ) -> ExchangeTokenResponse:
-        """Exchange token.
-
-        Exchange tokens with an Identity Provider to get a new access token. It allows specifying scopes to
+        """Exchange tokens with an Identity Provider to get a new access token. It allows specifying scopes to
         determine token permissions.
 
         :param partition_id: :class:`PartitionId`
@@ -6778,9 +7408,7 @@ class CspEnablementAccountAPI:
         self._api = api_client
 
     def get(self, *, etag: Optional[str] = None) -> CspEnablementAccountSetting:
-        """Get the compliance security profile setting for new workspaces.
-
-        Gets the compliance security profile setting for new workspaces.
+        """Gets the compliance security profile setting for new workspaces.
 
         :param etag: str (optional)
           etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
@@ -6810,9 +7438,7 @@ class CspEnablementAccountAPI:
     def update(
         self, allow_missing: bool, setting: CspEnablementAccountSetting, field_mask: str
     ) -> CspEnablementAccountSetting:
-        """Update the compliance security profile setting for new workspaces.
-
-        Updates the value of the compliance security profile setting for new workspaces.
+        """Updates the value of the compliance security profile setting for new workspaces.
 
         :param allow_missing: bool
           This should always be set to true for Settings API. Added for AIP compliance.
@@ -6851,6 +7477,106 @@ class CspEnablementAccountAPI:
         return CspEnablementAccountSetting.from_dict(res)
 
 
+class DashboardEmailSubscriptionsAPI:
+    """Controls whether schedules or workload tasks for refreshing AI/BI Dashboards in the workspace can send
+    subscription emails containing PDFs and/or images of the dashboard. By default, this setting is enabled
+    (set to `true`)"""
+
+    def __init__(self, api_client):
+        self._api = api_client
+
+    def delete(self, *, etag: Optional[str] = None) -> DeleteDashboardEmailSubscriptionsResponse:
+        """Reverts the Dashboard Email Subscriptions 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:`DeleteDashboardEmailSubscriptionsResponse`
+        """
+
+        query = {}
+        if etag is not None:
+            query["etag"] = etag
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do(
+            "DELETE",
+            "/api/2.0/settings/types/dashboard_email_subscriptions/names/default",
+            query=query,
+            headers=headers,
+        )
+        return DeleteDashboardEmailSubscriptionsResponse.from_dict(res)
+
+    def get(self, *, etag: Optional[str] = None) -> DashboardEmailSubscriptions:
+        """Gets the Dashboard Email Subscriptions 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:`DashboardEmailSubscriptions`
+        """
+
+        query = {}
+        if etag is not None:
+            query["etag"] = etag
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do(
+            "GET", "/api/2.0/settings/types/dashboard_email_subscriptions/names/default", query=query, headers=headers
+        )
+        return DashboardEmailSubscriptions.from_dict(res)
+
+    def update(
+        self, allow_missing: bool, setting: DashboardEmailSubscriptions, field_mask: str
+    ) -> DashboardEmailSubscriptions:
+        """Updates the Dashboard Email Subscriptions setting.
+
+        :param allow_missing: bool
+          This should always be set to true for Settings API. Added for AIP compliance.
+        :param setting: :class:`DashboardEmailSubscriptions`
+        :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:`DashboardEmailSubscriptions`
+        """
+        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/dashboard_email_subscriptions/names/default", body=body, headers=headers
+        )
+        return DashboardEmailSubscriptions.from_dict(res)
+
+
 class DefaultNamespaceAPI:
     """The default namespace setting API allows users to configure the default namespace for a Databricks
     workspace.
@@ -6867,9 +7593,7 @@ class DefaultNamespaceAPI:
         self._api = api_client
 
     def delete(self, *, etag: Optional[str] = None) -> DeleteDefaultNamespaceSettingResponse:
-        """Delete the default namespace setting.
-
-        Deletes the default namespace setting for the workspace. A fresh etag needs to be provided in `DELETE`
+        """Deletes the default namespace setting for the workspace. A fresh etag needs to be provided in `DELETE`
         requests (as a query parameter). The etag can be retrieved by making a `GET` request before the
         `DELETE` request. If the setting is updated/deleted concurrently, `DELETE` fails with 409 and the
         request must be retried by using the fresh etag in the 409 response.
@@ -6897,9 +7621,7 @@ class DefaultNamespaceAPI:
         return DeleteDefaultNamespaceSettingResponse.from_dict(res)
 
     def get(self, *, etag: Optional[str] = None) -> DefaultNamespaceSetting:
-        """Get the default namespace setting.
-
-        Gets the default namespace setting.
+        """Gets the default namespace setting.
 
         :param etag: str (optional)
           etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
@@ -6924,9 +7646,7 @@ class DefaultNamespaceAPI:
         return DefaultNamespaceSetting.from_dict(res)
 
     def update(self, allow_missing: bool, setting: DefaultNamespaceSetting, field_mask: str) -> DefaultNamespaceSetting:
-        """Update the default namespace setting.
-
-        Updates the default namespace setting for the workspace. A fresh etag needs to be provided in `PATCH`
+        """Updates the default namespace setting for the workspace. A fresh etag needs to be provided in `PATCH`
         requests (as part of the setting field). The etag can be retrieved by making a `GET` request before
         the `PATCH` request. Note that if the setting does not exist, `GET` returns a NOT_FOUND error and the
         etag is present in the error response, which should be set in the `PATCH` request. If the setting is
@@ -6985,9 +7705,7 @@ class DisableLegacyAccessAPI:
         self._api = api_client
 
     def delete(self, *, etag: Optional[str] = None) -> DeleteDisableLegacyAccessResponse:
-        """Delete Legacy Access Disablement Status.
-
-        Deletes legacy access disablement status.
+        """Deletes legacy access disablement status.
 
         :param etag: str (optional)
           etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
@@ -7012,9 +7730,7 @@ class DisableLegacyAccessAPI:
         return DeleteDisableLegacyAccessResponse.from_dict(res)
 
     def get(self, *, etag: Optional[str] = None) -> DisableLegacyAccess:
-        """Retrieve Legacy Access Disablement Status.
-
-        Retrieves legacy access disablement Status.
+        """Retrieves legacy access disablement Status.
 
         :param etag: str (optional)
           etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
@@ -7039,9 +7755,7 @@ class DisableLegacyAccessAPI:
         return DisableLegacyAccess.from_dict(res)
 
     def update(self, allow_missing: bool, setting: DisableLegacyAccess, field_mask: str) -> DisableLegacyAccess:
-        """Update Legacy Access Disablement Status.
-
-        Updates legacy access disablement status.
+        """Updates legacy access disablement status.
 
         :param allow_missing: bool
           This should always be set to true for Settings API. Added for AIP compliance.
@@ -7091,9 +7805,7 @@ class DisableLegacyDbfsAPI:
         self._api = api_client
 
     def delete(self, *, etag: Optional[str] = None) -> DeleteDisableLegacyDbfsResponse:
-        """Delete the disable legacy DBFS setting.
-
-        Deletes the disable legacy DBFS setting for a workspace, reverting back to the default.
+        """Deletes the disable legacy DBFS setting for a workspace, 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
@@ -7118,9 +7830,7 @@ class DisableLegacyDbfsAPI:
         return DeleteDisableLegacyDbfsResponse.from_dict(res)
 
     def get(self, *, etag: Optional[str] = None) -> DisableLegacyDbfs:
-        """Get the disable legacy DBFS setting.
-
-        Gets the disable legacy DBFS setting.
+        """Gets the disable legacy DBFS setting.
 
         :param etag: str (optional)
           etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
@@ -7145,9 +7855,7 @@ class DisableLegacyDbfsAPI:
         return DisableLegacyDbfs.from_dict(res)
 
     def update(self, allow_missing: bool, setting: DisableLegacyDbfs, field_mask: str) -> DisableLegacyDbfs:
-        """Update the disable legacy DBFS setting.
-
-        Updates the disable legacy DBFS setting for the workspace.
+        """Updates the disable legacy DBFS setting for the workspace.
 
         :param allow_missing: bool
           This should always be set to true for Settings API. Added for AIP compliance.
@@ -7194,9 +7902,7 @@ class DisableLegacyFeaturesAPI:
         self._api = api_client
 
     def delete(self, *, etag: Optional[str] = None) -> DeleteDisableLegacyFeaturesResponse:
-        """Delete the disable legacy features setting.
-
-        Deletes the disable legacy features setting.
+        """Deletes the disable legacy features setting.
 
         :param etag: str (optional)
           etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
@@ -7224,9 +7930,7 @@ class DisableLegacyFeaturesAPI:
         return DeleteDisableLegacyFeaturesResponse.from_dict(res)
 
     def get(self, *, etag: Optional[str] = None) -> DisableLegacyFeatures:
-        """Get the disable legacy features setting.
-
-        Gets the value of the disable legacy features setting.
+        """Gets the value of the disable legacy features setting.
 
         :param etag: str (optional)
           etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
@@ -7254,9 +7958,7 @@ class DisableLegacyFeaturesAPI:
         return DisableLegacyFeatures.from_dict(res)
 
     def update(self, allow_missing: bool, setting: DisableLegacyFeatures, field_mask: str) -> DisableLegacyFeatures:
-        """Update the disable legacy features setting.
-
-        Updates the value of the disable legacy features setting.
+        """Updates the value of the disable legacy features setting.
 
         :param allow_missing: bool
           This should always be set to true for Settings API. Added for AIP compliance.
@@ -7303,9 +8005,7 @@ class EnableExportNotebookAPI:
         self._api = api_client
 
     def get_enable_export_notebook(self) -> EnableExportNotebook:
-        """Get the Notebook and File exporting setting.
-
-        Gets the Notebook and File exporting setting.
+        """Gets the Notebook and File exporting setting.
 
         :returns: :class:`EnableExportNotebook`
         """
@@ -7320,9 +8020,7 @@ class EnableExportNotebookAPI:
     def patch_enable_export_notebook(
         self, allow_missing: bool, setting: EnableExportNotebook, field_mask: str
     ) -> EnableExportNotebook:
-        """Update the Notebook and File exporting setting.
-
-        Updates the Notebook and File exporting setting. The model follows eventual consistency, which means
+        """Updates the Notebook and File exporting setting. The model follows eventual consistency, which means
         the get after the update operation might receive stale values for some time.
 
         :param allow_missing: bool
@@ -7367,9 +8065,7 @@ class EnableIpAccessListsAPI:
         self._api = api_client
 
     def delete(self, *, etag: Optional[str] = None) -> DeleteAccountIpAccessEnableResponse:
-        """Delete the account IP access toggle setting.
-
-        Reverts the value of the account IP access toggle setting to default (ON)
+        """Reverts the value of the account IP access toggle setting to default (ON)
 
         :param etag: str (optional)
           etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
@@ -7397,9 +8093,7 @@ class EnableIpAccessListsAPI:
         return DeleteAccountIpAccessEnableResponse.from_dict(res)
 
     def get(self, *, etag: Optional[str] = None) -> AccountIpAccessEnable:
-        """Get the account IP access toggle setting.
-
-        Gets the value of the account IP access toggle setting.
+        """Gets the value of the account IP access toggle setting.
 
         :param etag: str (optional)
           etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
@@ -7427,9 +8121,7 @@ class EnableIpAccessListsAPI:
         return AccountIpAccessEnable.from_dict(res)
 
     def update(self, allow_missing: bool, setting: AccountIpAccessEnable, field_mask: str) -> AccountIpAccessEnable:
-        """Update the account IP access toggle setting.
-
-        Updates the value of the account IP access toggle setting.
+        """Updates the value of the account IP access toggle setting.
 
         :param allow_missing: bool
           This should always be set to true for Settings API. Added for AIP compliance.
@@ -7476,9 +8168,7 @@ class EnableNotebookTableClipboardAPI:
         self._api = api_client
 
     def get_enable_notebook_table_clipboard(self) -> EnableNotebookTableClipboard:
-        """Get the Results Table Clipboard features setting.
-
-        Gets the Results Table Clipboard features setting.
+        """Gets the Results Table Clipboard features setting.
 
         :returns: :class:`EnableNotebookTableClipboard`
         """
@@ -7495,9 +8185,7 @@ class EnableNotebookTableClipboardAPI:
     def patch_enable_notebook_table_clipboard(
         self, allow_missing: bool, setting: EnableNotebookTableClipboard, field_mask: str
     ) -> EnableNotebookTableClipboard:
-        """Update the Results Table Clipboard features setting.
-
-        Updates the Results Table Clipboard features setting. The model follows eventual consistency, which
+        """Updates the Results Table Clipboard features setting. The model follows eventual consistency, which
         means the get after the update operation might receive stale values for some time.
 
         :param allow_missing: bool
@@ -7541,9 +8229,7 @@ class EnableResultsDownloadingAPI:
         self._api = api_client
 
     def get_enable_results_downloading(self) -> EnableResultsDownloading:
-        """Get the Notebook results download setting.
-
-        Gets the Notebook results download setting.
+        """Gets the Notebook results download setting.
 
         :returns: :class:`EnableResultsDownloading`
         """
@@ -7558,9 +8244,7 @@ class EnableResultsDownloadingAPI:
     def patch_enable_results_downloading(
         self, allow_missing: bool, setting: EnableResultsDownloading, field_mask: str
     ) -> EnableResultsDownloading:
-        """Update the Notebook results download setting.
-
-        Updates the Notebook results download setting. The model follows eventual consistency, which means the
+        """Updates the Notebook results download setting. The model follows eventual consistency, which means the
         get after the update operation might receive stale values for some time.
 
         :param allow_missing: bool
@@ -7609,9 +8293,7 @@ class EnhancedSecurityMonitoringAPI:
         self._api = api_client
 
     def get(self, *, etag: Optional[str] = None) -> EnhancedSecurityMonitoringSetting:
-        """Get the enhanced security monitoring setting.
-
-        Gets the enhanced security monitoring setting.
+        """Gets the enhanced security monitoring setting.
 
         :param etag: str (optional)
           etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
@@ -7638,9 +8320,7 @@ class EnhancedSecurityMonitoringAPI:
     def update(
         self, allow_missing: bool, setting: EnhancedSecurityMonitoringSetting, field_mask: str
     ) -> EnhancedSecurityMonitoringSetting:
-        """Update the enhanced security monitoring setting.
-
-        Updates the enhanced security monitoring setting for the workspace. A fresh etag needs to be provided
+        """Updates the enhanced security monitoring setting for the workspace. A fresh etag needs to be provided
         in `PATCH` requests (as part of the setting field). The etag can be retrieved by making a `GET`
         request before the `PATCH` request. If the setting is updated concurrently, `PATCH` fails with 409 and
         the request must be retried by using the fresh etag in the 409 response.
@@ -7688,9 +8368,7 @@ class EsmEnablementAccountAPI:
         self._api = api_client
 
     def get(self, *, etag: Optional[str] = None) -> EsmEnablementAccountSetting:
-        """Get the enhanced security monitoring setting for new workspaces.
-
-        Gets the enhanced security monitoring setting for new workspaces.
+        """Gets the enhanced security monitoring setting for new workspaces.
 
         :param etag: str (optional)
           etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
@@ -7720,9 +8398,7 @@ class EsmEnablementAccountAPI:
     def update(
         self, allow_missing: bool, setting: EsmEnablementAccountSetting, field_mask: str
     ) -> EsmEnablementAccountSetting:
-        """Update the enhanced security monitoring setting for new workspaces.
-
-        Updates the value of the enhanced security monitoring setting for new workspaces.
+        """Updates the value of the enhanced security monitoring setting for new workspaces.
 
         :param allow_missing: bool
           This should always be set to true for Settings API. Added for AIP compliance.
@@ -7786,9 +8462,7 @@ class IpAccessListsAPI:
     def create(
         self, label: str, list_type: ListType, *, ip_addresses: Optional[List[str]] = None
     ) -> CreateIpAccessListResponse:
-        """Create access list.
-
-        Creates an IP access list for this workspace.
+        """Creates an IP access list for this workspace.
 
         A list can be an allow list or a block list. See the top of this file for a description of how the
         server treats allow lists and block lists at runtime.
@@ -7830,9 +8504,7 @@ class IpAccessListsAPI:
         return CreateIpAccessListResponse.from_dict(res)
 
     def delete(self, ip_access_list_id: str):
-        """Delete access list.
-
-        Deletes an IP access list, specified by its list ID.
+        """Deletes an IP access list, specified by its list ID.
 
         :param ip_access_list_id: str
           The ID for the corresponding IP access list
@@ -7845,9 +8517,7 @@ class IpAccessListsAPI:
         self._api.do("DELETE", f"/api/2.0/ip-access-lists/{ip_access_list_id}", headers=headers)
 
     def get(self, ip_access_list_id: str) -> FetchIpAccessListResponse:
-        """Get access list.
-
-        Gets an IP access list, specified by its list ID.
+        """Gets an IP access list, specified by its list ID.
 
         :param ip_access_list_id: str
           The ID for the corresponding IP access list
@@ -7863,9 +8533,7 @@ class IpAccessListsAPI:
         return FetchIpAccessListResponse.from_dict(res)
 
     def list(self) -> Iterator[IpAccessListInfo]:
-        """Get access lists.
-
-        Gets all IP access lists for the specified workspace.
+        """Gets all IP access lists for the specified workspace.
 
         :returns: Iterator over :class:`IpAccessListInfo`
         """
@@ -7887,9 +8555,7 @@ class IpAccessListsAPI:
         *,
         ip_addresses: Optional[List[str]] = None,
     ):
-        """Replace access list.
-
-        Replaces an IP access list, specified by its ID.
+        """Replaces an IP access list, specified by its ID.
 
         A list can include allow lists and block lists. See the top of this file for a description of how the
         server treats allow lists and block lists at run time. When replacing an IP access list: * For all
@@ -7939,9 +8605,7 @@ class IpAccessListsAPI:
         label: Optional[str] = None,
         list_type: Optional[ListType] = None,
     ):
-        """Update access list.
-
-        Updates an existing IP access list, specified by its ID.
+        """Updates an existing IP access list, specified by its ID.
 
         A list can include allow lists and block lists. See the top of this file for a description of how the
         server treats allow lists and block lists at run time.
@@ -7994,9 +8658,7 @@ class LlmProxyPartnerPoweredAccountAPI:
         self._api = api_client
 
     def get(self, *, etag: Optional[str] = None) -> LlmProxyPartnerPoweredAccount:
-        """Get the enable partner powered AI features account setting.
-
-        Gets the enable partner powered AI features account setting.
+        """Gets the enable partner powered AI features account setting.
 
         :param etag: str (optional)
           etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
@@ -8026,9 +8688,7 @@ class LlmProxyPartnerPoweredAccountAPI:
     def update(
         self, allow_missing: bool, setting: LlmProxyPartnerPoweredAccount, field_mask: str
     ) -> LlmProxyPartnerPoweredAccount:
-        """Update the enable partner powered AI features account setting.
-
-        Updates the enable partner powered AI features account setting.
+        """Updates the enable partner powered AI features account setting.
 
         :param allow_missing: bool
           This should always be set to true for Settings API. Added for AIP compliance.
@@ -8075,9 +8735,7 @@ class LlmProxyPartnerPoweredEnforceAPI:
         self._api = api_client
 
     def get(self, *, etag: Optional[str] = None) -> LlmProxyPartnerPoweredEnforce:
-        """Get the enforcement status of partner powered AI features account setting.
-
-        Gets the enforcement status of partner powered AI features account setting.
+        """Gets the enforcement status of partner powered AI features account setting.
 
         :param etag: str (optional)
           etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
@@ -8107,9 +8765,7 @@ class LlmProxyPartnerPoweredEnforceAPI:
     def update(
         self, allow_missing: bool, setting: LlmProxyPartnerPoweredEnforce, field_mask: str
     ) -> LlmProxyPartnerPoweredEnforce:
-        """Update the enforcement status of partner powered AI features account setting.
-
-        Updates the enable enforcement status of partner powered AI features account setting.
+        """Updates the enable enforcement status of partner powered AI features account setting.
 
         :param allow_missing: bool
           This should always be set to true for Settings API. Added for AIP compliance.
@@ -8155,9 +8811,7 @@ class LlmProxyPartnerPoweredWorkspaceAPI:
         self._api = api_client
 
     def delete(self, *, etag: Optional[str] = None) -> DeleteLlmProxyPartnerPoweredWorkspaceResponse:
-        """Delete the enable partner powered AI features workspace setting.
-
-        Reverts the enable partner powered AI features workspace setting to its default value.
+        """Reverts the enable partner powered AI features workspace 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
@@ -8182,9 +8836,7 @@ class LlmProxyPartnerPoweredWorkspaceAPI:
         return DeleteLlmProxyPartnerPoweredWorkspaceResponse.from_dict(res)
 
     def get(self, *, etag: Optional[str] = None) -> LlmProxyPartnerPoweredWorkspace:
-        """Get the enable partner powered AI features workspace setting.
-
-        Gets the enable partner powered AI features workspace setting.
+        """Gets the enable partner powered AI features workspace setting.
 
         :param etag: str (optional)
           etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
@@ -8211,9 +8863,7 @@ class LlmProxyPartnerPoweredWorkspaceAPI:
     def update(
         self, allow_missing: bool, setting: LlmProxyPartnerPoweredWorkspace, field_mask: str
     ) -> LlmProxyPartnerPoweredWorkspace:
-        """Update the enable partner powered AI features workspace setting.
-
-        Updates the enable partner powered AI features workspace setting.
+        """Updates the enable partner powered AI features workspace setting.
 
         :param allow_missing: bool
           This should always be set to true for Settings API. Added for AIP compliance.
@@ -8265,9 +8915,7 @@ class NetworkConnectivityAPI:
     def create_network_connectivity_configuration(
         self, network_connectivity_config: CreateNetworkConnectivityConfiguration
     ) -> NetworkConnectivityConfiguration:
-        """Create a network connectivity configuration.
-
-        Creates a network connectivity configuration (NCC), which provides stable Azure service subnets when
+        """Creates a network connectivity configuration (NCC), which provides stable Azure service subnets when
         accessing your Azure Storage accounts. You can also use a network connectivity configuration to create
         Databricks managed private endpoints so that Databricks serverless compute resources privately access
         your resources.
@@ -8297,10 +8945,8 @@ class NetworkConnectivityAPI:
 
     def create_private_endpoint_rule(
         self, network_connectivity_config_id: str, private_endpoint_rule: CreatePrivateEndpointRule
-    ) -> NccAzurePrivateEndpointRule:
-        """Create a private endpoint rule.
-
-        Create a private endpoint rule for the specified network connectivity config object. Once the object
+    ) -> NccPrivateEndpointRule:
+        """Create a private endpoint rule for the specified network connectivity config object. Once the object
         is created, Databricks asynchronously provisions a new Azure private endpoint to your specified Azure
         resource.
 
@@ -8316,7 +8962,7 @@ class NetworkConnectivityAPI:
           Properties of the new private endpoint rule. Note that you must approve the endpoint in Azure portal
           after initialization.
 
-        :returns: :class:`NccAzurePrivateEndpointRule`
+        :returns: :class:`NccPrivateEndpointRule`
         """
         body = private_endpoint_rule.as_dict()
         headers = {
@@ -8330,12 +8976,10 @@ class NetworkConnectivityAPI:
             body=body,
             headers=headers,
         )
-        return NccAzurePrivateEndpointRule.from_dict(res)
+        return NccPrivateEndpointRule.from_dict(res)
 
     def delete_network_connectivity_configuration(self, network_connectivity_config_id: str):
-        """Delete a network connectivity configuration.
-
-        Deletes a network connectivity configuration.
+        """Deletes a network connectivity configuration.
 
         :param network_connectivity_config_id: str
           Your Network Connectivity Configuration ID.
@@ -8355,10 +8999,8 @@ class NetworkConnectivityAPI:
 
     def delete_private_endpoint_rule(
         self, network_connectivity_config_id: str, private_endpoint_rule_id: str
-    ) -> NccAzurePrivateEndpointRule:
-        """Delete a private endpoint rule.
-
-        Initiates deleting a private endpoint rule. If the connection state is PENDING or EXPIRED, the private
+    ) -> NccPrivateEndpointRule:
+        """Initiates deleting a private endpoint rule. If the connection state is PENDING or EXPIRED, the private
         endpoint is immediately deleted. Otherwise, the private endpoint is deactivated and will be deleted
         after seven days of deactivation. When a private endpoint is deactivated, the `deactivated` field is
         set to `true` and the private endpoint is not available to your serverless compute resources.
@@ -8368,7 +9010,7 @@ class NetworkConnectivityAPI:
         :param private_endpoint_rule_id: str
           Your private endpoint rule ID.
 
-        :returns: :class:`NccAzurePrivateEndpointRule`
+        :returns: :class:`NccPrivateEndpointRule`
         """
 
         headers = {
@@ -8380,14 +9022,12 @@ class NetworkConnectivityAPI:
             f"/api/2.0/accounts/{self._api.account_id}/network-connectivity-configs/{network_connectivity_config_id}/private-endpoint-rules/{private_endpoint_rule_id}",
             headers=headers,
         )
-        return NccAzurePrivateEndpointRule.from_dict(res)
+        return NccPrivateEndpointRule.from_dict(res)
 
     def get_network_connectivity_configuration(
         self, network_connectivity_config_id: str
     ) -> NetworkConnectivityConfiguration:
-        """Get a network connectivity configuration.
-
-        Gets a network connectivity configuration.
+        """Gets a network connectivity configuration.
 
         :param network_connectivity_config_id: str
           Your Network Connectivity Configuration ID.
@@ -8408,17 +9048,15 @@ class NetworkConnectivityAPI:
 
     def get_private_endpoint_rule(
         self, network_connectivity_config_id: str, private_endpoint_rule_id: str
-    ) -> NccAzurePrivateEndpointRule:
-        """Gets a private endpoint rule.
-
-        Gets the private endpoint rule.
+    ) -> NccPrivateEndpointRule:
+        """Gets the private endpoint rule.
 
         :param network_connectivity_config_id: str
           Your Network Connectvity Configuration ID.
         :param private_endpoint_rule_id: str
           Your private endpoint rule ID.
 
-        :returns: :class:`NccAzurePrivateEndpointRule`
+        :returns: :class:`NccPrivateEndpointRule`
         """
 
         headers = {
@@ -8430,14 +9068,12 @@ class NetworkConnectivityAPI:
             f"/api/2.0/accounts/{self._api.account_id}/network-connectivity-configs/{network_connectivity_config_id}/private-endpoint-rules/{private_endpoint_rule_id}",
             headers=headers,
         )
-        return NccAzurePrivateEndpointRule.from_dict(res)
+        return NccPrivateEndpointRule.from_dict(res)
 
     def list_network_connectivity_configurations(
         self, *, page_token: Optional[str] = None
     ) -> Iterator[NetworkConnectivityConfiguration]:
-        """List network connectivity configurations.
-
-        Gets an array of network connectivity configurations.
+        """Gets an array of network connectivity configurations.
 
         :param page_token: str (optional)
           Pagination token to go to next page based on previous query.
@@ -8468,17 +9104,15 @@ class NetworkConnectivityAPI:
 
     def list_private_endpoint_rules(
         self, network_connectivity_config_id: str, *, page_token: Optional[str] = None
-    ) -> Iterator[NccAzurePrivateEndpointRule]:
-        """List private endpoint rules.
-
-        Gets an array of private endpoint rules.
+    ) -> Iterator[NccPrivateEndpointRule]:
+        """Gets an array of private endpoint rules.
 
         :param network_connectivity_config_id: str
           Your Network Connectvity Configuration ID.
         :param page_token: str (optional)
           Pagination token to go to next page based on previous query.
 
-        :returns: Iterator over :class:`NccAzurePrivateEndpointRule`
+        :returns: Iterator over :class:`NccPrivateEndpointRule`
         """
 
         query = {}
@@ -8497,25 +9131,24 @@ class NetworkConnectivityAPI:
             )
             if "items" in json:
                 for v in json["items"]:
-                    yield NccAzurePrivateEndpointRule.from_dict(v)
+                    yield NccPrivateEndpointRule.from_dict(v)
             if "next_page_token" not in json or not json["next_page_token"]:
                 return
             query["page_token"] = json["next_page_token"]
 
-    def update_ncc_azure_private_endpoint_rule_public(
+    def update_private_endpoint_rule(
         self,
         network_connectivity_config_id: str,
         private_endpoint_rule_id: str,
         private_endpoint_rule: UpdatePrivateEndpointRule,
         update_mask: str,
-    ) -> NccAzurePrivateEndpointRule:
-        """Update a private endpoint rule.
-
-        Updates a private endpoint rule. Currently only a private endpoint rule to customer-managed resources
+    ) -> NccPrivateEndpointRule:
+        """Updates a private endpoint rule. Currently only a private endpoint rule to customer-managed resources
         is allowed to be updated.
 
         :param network_connectivity_config_id: str
-          Your Network Connectivity Configuration ID.
+          The ID of a network connectivity configuration, which is the parent resource of this private
+          endpoint rule object.
         :param private_endpoint_rule_id: str
           Your private endpoint rule ID.
         :param private_endpoint_rule: :class:`UpdatePrivateEndpointRule`
@@ -8528,7 +9161,7 @@ class NetworkConnectivityAPI:
           the entire collection field can be specified. Field names must exactly match the resource field
           names.
 
-        :returns: :class:`NccAzurePrivateEndpointRule`
+        :returns: :class:`NccPrivateEndpointRule`
         """
         body = private_endpoint_rule.as_dict()
         query = {}
@@ -8546,7 +9179,7 @@ class NetworkConnectivityAPI:
             body=body,
             headers=headers,
         )
-        return NccAzurePrivateEndpointRule.from_dict(res)
+        return NccPrivateEndpointRule.from_dict(res)
 
 
 class NetworkPoliciesAPI:
@@ -8561,9 +9194,7 @@ class NetworkPoliciesAPI:
         self._api = api_client
 
     def create_network_policy_rpc(self, network_policy: AccountNetworkPolicy) -> AccountNetworkPolicy:
-        """Create a network policy.
-
-        Creates a new network policy to manage which network destinations can be accessed from the Databricks
+        """Creates a new network policy to manage which network destinations can be accessed from the Databricks
         environment.
 
         :param network_policy: :class:`AccountNetworkPolicy`
@@ -8582,9 +9213,7 @@ class NetworkPoliciesAPI:
         return AccountNetworkPolicy.from_dict(res)
 
     def delete_network_policy_rpc(self, network_policy_id: str):
-        """Delete a network policy.
-
-        Deletes a network policy. Cannot be called on 'default-policy'.
+        """Deletes a network policy. Cannot be called on 'default-policy'.
 
         :param network_policy_id: str
           The unique identifier of the network policy to delete.
@@ -8601,9 +9230,7 @@ class NetworkPoliciesAPI:
         )
 
     def get_network_policy_rpc(self, network_policy_id: str) -> AccountNetworkPolicy:
-        """Get a network policy.
-
-        Gets a network policy.
+        """Gets a network policy.
 
         :param network_policy_id: str
           The unique identifier of the network policy to retrieve.
@@ -8621,9 +9248,7 @@ class NetworkPoliciesAPI:
         return AccountNetworkPolicy.from_dict(res)
 
     def list_network_policies_rpc(self, *, page_token: Optional[str] = None) -> Iterator[AccountNetworkPolicy]:
-        """List network policies.
-
-        Gets an array of network policies.
+        """Gets an array of network policies.
 
         :param page_token: str (optional)
           Pagination token to go to next page based on previous query.
@@ -8652,9 +9277,7 @@ class NetworkPoliciesAPI:
     def update_network_policy_rpc(
         self, network_policy_id: str, network_policy: AccountNetworkPolicy
     ) -> AccountNetworkPolicy:
-        """Update a network policy.
-
-        Updates a network policy. This allows you to modify the configuration of a network policy.
+        """Updates a network policy. This allows you to modify the configuration of a network policy.
 
         :param network_policy_id: str
           The unique identifier for the network policy.
@@ -8687,9 +9310,7 @@ class NotificationDestinationsAPI:
         self._api = api_client
 
     def create(self, *, config: Optional[Config] = None, display_name: Optional[str] = None) -> NotificationDestination:
-        """Create a notification destination.
-
-        Creates a notification destination. Requires workspace admin permissions.
+        """Creates a notification destination. Requires workspace admin permissions.
 
         :param config: :class:`Config` (optional)
           The configuration for the notification destination. Must wrap EXACTLY one of the nested configs.
@@ -8712,9 +9333,7 @@ class NotificationDestinationsAPI:
         return NotificationDestination.from_dict(res)
 
     def delete(self, id: str):
-        """Delete a notification destination.
-
-        Deletes a notification destination. Requires workspace admin permissions.
+        """Deletes a notification destination. Requires workspace admin permissions.
 
         :param id: str
 
@@ -8728,9 +9347,7 @@ class NotificationDestinationsAPI:
         self._api.do("DELETE", f"/api/2.0/notification-destinations/{id}", headers=headers)
 
     def get(self, id: str) -> NotificationDestination:
-        """Get a notification destination.
-
-        Gets a notification destination.
+        """Gets a notification destination.
 
         :param id: str
 
@@ -8747,9 +9364,7 @@ class NotificationDestinationsAPI:
     def list(
         self, *, page_size: Optional[int] = None, page_token: Optional[str] = None
     ) -> Iterator[ListNotificationDestinationsResult]:
-        """List notification destinations.
-
-        Lists notification destinations.
+        """Lists notification destinations.
 
         :param page_size: int (optional)
         :param page_token: str (optional)
@@ -8778,9 +9393,7 @@ class NotificationDestinationsAPI:
     def update(
         self, id: str, *, config: Optional[Config] = None, display_name: Optional[str] = None
     ) -> NotificationDestination:
-        """Update a notification destination.
-
-        Updates a notification destination. Requires workspace admin permissions. At least one field is
+        """Updates a notification destination. Requires workspace admin permissions. At least one field is
         required in the request body.
 
         :param id: str
@@ -8819,9 +9432,7 @@ class PersonalComputeAPI:
         self._api = api_client
 
     def delete(self, *, etag: Optional[str] = None) -> DeletePersonalComputeSettingResponse:
-        """Delete Personal Compute setting.
-
-        Reverts back the Personal Compute setting value to default (ON)
+        """Reverts back the Personal Compute setting value to default (ON)
 
         :param etag: str (optional)
           etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
@@ -8849,9 +9460,7 @@ class PersonalComputeAPI:
         return DeletePersonalComputeSettingResponse.from_dict(res)
 
     def get(self, *, etag: Optional[str] = None) -> PersonalComputeSetting:
-        """Get Personal Compute setting.
-
-        Gets the value of the Personal Compute setting.
+        """Gets the value of the Personal Compute setting.
 
         :param etag: str (optional)
           etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
@@ -8879,9 +9488,7 @@ class PersonalComputeAPI:
         return PersonalComputeSetting.from_dict(res)
 
     def update(self, allow_missing: bool, setting: PersonalComputeSetting, field_mask: str) -> PersonalComputeSetting:
-        """Update Personal Compute setting.
-
-        Updates the value of the Personal Compute setting.
+        """Updates the value of the Personal Compute setting.
 
         :param allow_missing: bool
           This should always be set to true for Settings API. Added for AIP compliance.
@@ -8935,9 +9542,7 @@ class RestrictWorkspaceAdminsAPI:
         self._api = api_client
 
     def delete(self, *, etag: Optional[str] = None) -> DeleteRestrictWorkspaceAdminsSettingResponse:
-        """Delete the restrict workspace admins setting.
-
-        Reverts the restrict workspace admins setting status for the workspace. A fresh etag needs to be
+        """Reverts the restrict workspace admins setting status for the workspace. A fresh etag needs to be
         provided in `DELETE` requests (as a query parameter). The etag can be retrieved by making a `GET`
         request before the DELETE request. If the setting is updated/deleted concurrently, `DELETE` fails with
         409 and the request must be retried by using the fresh etag in the 409 response.
@@ -8965,9 +9570,7 @@ class RestrictWorkspaceAdminsAPI:
         return DeleteRestrictWorkspaceAdminsSettingResponse.from_dict(res)
 
     def get(self, *, etag: Optional[str] = None) -> RestrictWorkspaceAdminsSetting:
-        """Get the restrict workspace admins setting.
-
-        Gets the restrict workspace admins setting.
+        """Gets the restrict workspace admins setting.
 
         :param etag: str (optional)
           etag used for versioning. The response is at least as fresh as the eTag provided. This is used for
@@ -8994,9 +9597,7 @@ class RestrictWorkspaceAdminsAPI:
     def update(
         self, allow_missing: bool, setting: RestrictWorkspaceAdminsSetting, field_mask: str
     ) -> RestrictWorkspaceAdminsSetting:
-        """Update the restrict workspace admins setting.
-
-        Updates the restrict workspace admins setting for the workspace. A fresh etag needs to be provided in
+        """Updates the restrict workspace admins setting for the workspace. A fresh etag needs to be provided in
         `PATCH` requests (as part of the setting field). The etag can be retrieved by making a GET request
         before the `PATCH` request. If the setting is updated concurrently, `PATCH` fails with 409 and the
         request must be retried by using the fresh etag in the 409 response.
@@ -9045,6 +9646,7 @@ class SettingsAPI:
         self._aibi_dashboard_embedding_approved_domains = AibiDashboardEmbeddingApprovedDomainsAPI(self._api)
         self._automatic_cluster_update = AutomaticClusterUpdateAPI(self._api)
         self._compliance_security_profile = ComplianceSecurityProfileAPI(self._api)
+        self._dashboard_email_subscriptions = DashboardEmailSubscriptionsAPI(self._api)
         self._default_namespace = DefaultNamespaceAPI(self._api)
         self._disable_legacy_access = DisableLegacyAccessAPI(self._api)
         self._disable_legacy_dbfs = DisableLegacyDbfsAPI(self._api)
@@ -9054,6 +9656,7 @@ class SettingsAPI:
         self._enhanced_security_monitoring = EnhancedSecurityMonitoringAPI(self._api)
         self._llm_proxy_partner_powered_workspace = LlmProxyPartnerPoweredWorkspaceAPI(self._api)
         self._restrict_workspace_admins = RestrictWorkspaceAdminsAPI(self._api)
+        self._sql_results_download = SqlResultsDownloadAPI(self._api)
 
     @property
     def aibi_dashboard_embedding_access_policy(self) -> AibiDashboardEmbeddingAccessPolicyAPI:
@@ -9075,6 +9678,11 @@ class SettingsAPI:
         """Controls whether to enable the compliance security profile for the current workspace."""
         return self._compliance_security_profile
 
+    @property
+    def dashboard_email_subscriptions(self) -> DashboardEmailSubscriptionsAPI:
+        """Controls whether schedules or workload tasks for refreshing AI/BI Dashboards in the workspace can send subscription emails containing PDFs and/or images of the dashboard."""
+        return self._dashboard_email_subscriptions
+
     @property
     def default_namespace(self) -> DefaultNamespaceAPI:
         """The default namespace setting API allows users to configure the default namespace for a Databricks workspace."""
@@ -9120,6 +9728,105 @@ class SettingsAPI:
         """The Restrict Workspace Admins setting lets you control the capabilities of workspace admins."""
         return self._restrict_workspace_admins
 
+    @property
+    def sql_results_download(self) -> SqlResultsDownloadAPI:
+        """Controls whether users within the workspace are allowed to download results from the SQL Editor and AI/BI Dashboards UIs."""
+        return self._sql_results_download
+
+
+class SqlResultsDownloadAPI:
+    """Controls whether users within the workspace are allowed to download results from the SQL Editor and AI/BI
+    Dashboards UIs. By default, this setting is enabled (set to `true`)"""
+
+    def __init__(self, api_client):
+        self._api = api_client
+
+    def delete(self, *, etag: Optional[str] = None) -> DeleteSqlResultsDownloadResponse:
+        """Reverts the SQL Results Download 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:`DeleteSqlResultsDownloadResponse`
+        """
+
+        query = {}
+        if etag is not None:
+            query["etag"] = etag
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do(
+            "DELETE", "/api/2.0/settings/types/sql_results_download/names/default", query=query, headers=headers
+        )
+        return DeleteSqlResultsDownloadResponse.from_dict(res)
+
+    def get(self, *, etag: Optional[str] = None) -> SqlResultsDownload:
+        """Gets the SQL Results Download 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:`SqlResultsDownload`
+        """
+
+        query = {}
+        if etag is not None:
+            query["etag"] = etag
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do(
+            "GET", "/api/2.0/settings/types/sql_results_download/names/default", query=query, headers=headers
+        )
+        return SqlResultsDownload.from_dict(res)
+
+    def update(self, allow_missing: bool, setting: SqlResultsDownload, field_mask: str) -> SqlResultsDownload:
+        """Updates the SQL Results Download setting.
+
+        :param allow_missing: bool
+          This should always be set to true for Settings API. Added for AIP compliance.
+        :param setting: :class:`SqlResultsDownload`
+        :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:`SqlResultsDownload`
+        """
+        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/sql_results_download/names/default", body=body, headers=headers
+        )
+        return SqlResultsDownload.from_dict(res)
+
 
 class TokenManagementAPI:
     """Enables administrators to get all tokens and delete tokens for other users. Admins can either get every
@@ -9131,9 +9838,7 @@ class TokenManagementAPI:
     def create_obo_token(
         self, application_id: str, *, comment: Optional[str] = None, lifetime_seconds: Optional[int] = None
     ) -> CreateOboTokenResponse:
-        """Create on-behalf token.
-
-        Creates a token on behalf of a service principal.
+        """Creates a token on behalf of a service principal.
 
         :param application_id: str
           Application ID of the service principal.
@@ -9160,9 +9865,7 @@ class TokenManagementAPI:
         return CreateOboTokenResponse.from_dict(res)
 
     def delete(self, token_id: str):
-        """Delete a token.
-
-        Deletes a token, specified by its ID.
+        """Deletes a token, specified by its ID.
 
         :param token_id: str
           The ID of the token to revoke.
@@ -9175,9 +9878,7 @@ class TokenManagementAPI:
         self._api.do("DELETE", f"/api/2.0/token-management/tokens/{token_id}", headers=headers)
 
     def get(self, token_id: str) -> GetTokenResponse:
-        """Get token info.
-
-        Gets information about a token, specified by its ID.
+        """Gets information about a token, specified by its ID.
 
         :param token_id: str
           The ID of the token to get.
@@ -9193,9 +9894,7 @@ class TokenManagementAPI:
         return GetTokenResponse.from_dict(res)
 
     def get_permission_levels(self) -> GetTokenPermissionLevelsResponse:
-        """Get token permission levels.
-
-        Gets the permission levels that a user can have on an object.
+        """Gets the permission levels that a user can have on an object.
 
         :returns: :class:`GetTokenPermissionLevelsResponse`
         """
@@ -9208,9 +9907,7 @@ class TokenManagementAPI:
         return GetTokenPermissionLevelsResponse.from_dict(res)
 
     def get_permissions(self) -> TokenPermissions:
-        """Get token permissions.
-
-        Gets the permissions of all tokens. Tokens can inherit permissions from their root object.
+        """Gets the permissions of all tokens. Tokens can inherit permissions from their root object.
 
         :returns: :class:`TokenPermissions`
         """
@@ -9225,9 +9922,7 @@ class TokenManagementAPI:
     def list(
         self, *, created_by_id: Optional[int] = None, created_by_username: Optional[str] = None
     ) -> Iterator[TokenInfo]:
-        """List all tokens.
-
-        Lists all tokens associated with the specified workspace or user.
+        """Lists all tokens associated with the specified workspace or user.
 
         :param created_by_id: int (optional)
           User ID of the user that created the token.
@@ -9253,9 +9948,7 @@ class TokenManagementAPI:
     def set_permissions(
         self, *, access_control_list: Optional[List[TokenAccessControlRequest]] = None
     ) -> TokenPermissions:
-        """Set token permissions.
-
-        Sets permissions on an object, replacing existing permissions if they exist. Deletes all direct
+        """Sets permissions on an object, replacing existing permissions if they exist. Deletes all direct
         permissions if none are specified. Objects can inherit permissions from their root object.
 
         :param access_control_list: List[:class:`TokenAccessControlRequest`] (optional)
@@ -9276,9 +9969,7 @@ class TokenManagementAPI:
     def update_permissions(
         self, *, access_control_list: Optional[List[TokenAccessControlRequest]] = None
     ) -> TokenPermissions:
-        """Update token permissions.
-
-        Updates the permissions on all tokens. Tokens can inherit permissions from their root object.
+        """Updates the permissions on all tokens. Tokens can inherit permissions from their root object.
 
         :param access_control_list: List[:class:`TokenAccessControlRequest`] (optional)
 
@@ -9304,9 +9995,7 @@ class TokensAPI:
         self._api = api_client
 
     def create(self, *, comment: Optional[str] = None, lifetime_seconds: Optional[int] = None) -> CreateTokenResponse:
-        """Create a user token.
-
-        Creates and returns a token for a user. If this call is made through token authentication, it creates
+        """Creates and returns a token for a user. If this call is made through token authentication, it creates
         a token with the same client ID as the authenticated token. If the user's token quota is exceeded,
         this call returns an error **QUOTA_EXCEEDED**.
 
@@ -9333,9 +10022,7 @@ class TokensAPI:
         return CreateTokenResponse.from_dict(res)
 
     def delete(self, token_id: str):
-        """Revoke token.
-
-        Revokes an access token.
+        """Revokes an access token.
 
         If a token with the specified ID is not valid, this call returns an error **RESOURCE_DOES_NOT_EXIST**.
 
@@ -9355,9 +10042,7 @@ class TokensAPI:
         self._api.do("POST", "/api/2.0/token/delete", body=body, headers=headers)
 
     def list(self) -> Iterator[PublicTokenInfo]:
-        """List tokens.
-
-        Lists all the valid tokens for a user-workspace pair.
+        """Lists all the valid tokens for a user-workspace pair.
 
         :returns: Iterator over :class:`PublicTokenInfo`
         """
@@ -9378,9 +10063,7 @@ class WorkspaceConfAPI:
         self._api = api_client
 
     def get_status(self, keys: str) -> WorkspaceConf:
-        """Check configuration status.
-
-        Gets the configuration status for a workspace.
+        """Gets the configuration status for a workspace.
 
         :param keys: str
 
@@ -9398,13 +10081,7 @@ class WorkspaceConfAPI:
         return res
 
     def set_status(self, contents: Dict[str, str]):
-        """Enable/disable features.
-
-        Sets the configuration status for a workspace, including enabling or disabling it.
-
-
-
-        """
+        """Sets the configuration status for a workspace, including enabling or disabling it."""
 
         headers = {
             "Content-Type": "application/json",
@@ -9414,20 +10091,18 @@ class WorkspaceConfAPI:
 
 
 class WorkspaceNetworkConfigurationAPI:
-    """These APIs allow configuration of network settings for Databricks workspaces. Each workspace is always
-    associated with exactly one network policy that controls which network destinations can be accessed from
-    the Databricks environment. By default, workspaces are associated with the 'default-policy' network
-    policy. You cannot create or delete a workspace's network configuration, only update it to associate the
-    workspace with a different policy."""
+    """These APIs allow configuration of network settings for Databricks workspaces by selecting which network
+    policy to associate with the workspace. Each workspace is always associated with exactly one network
+    policy that controls which network destinations can be accessed from the Databricks environment. By
+    default, workspaces are associated with the 'default-policy' network policy. You cannot create or delete a
+    workspace's network option, only update it to associate the workspace with a different policy"""
 
     def __init__(self, api_client):
         self._api = api_client
 
     def get_workspace_network_option_rpc(self, workspace_id: int) -> WorkspaceNetworkOption:
-        """Get workspace network configuration.
-
-        Gets the network configuration for a workspace. Every workspace has exactly one network policy
-        binding, with 'default-policy' used if no explicit assignment exists.
+        """Gets the network option for a workspace. Every workspace has exactly one network policy binding, with
+        'default-policy' used if no explicit assignment exists.
 
         :param workspace_id: int
           The workspace ID.
@@ -9447,11 +10122,8 @@ class WorkspaceNetworkConfigurationAPI:
     def update_workspace_network_option_rpc(
         self, workspace_id: int, workspace_network_option: WorkspaceNetworkOption
     ) -> WorkspaceNetworkOption:
-        """Update workspace network configuration.
-
-        Updates the network configuration for a workspace. This operation associates the workspace with the
-        specified network policy. To revert to the default policy, specify 'default-policy' as the
-        network_policy_id.
+        """Updates the network option for a workspace. This operation associates the workspace with the specified
+        network policy. To revert to the default policy, specify 'default-policy' as the network_policy_id.
 
         :param workspace_id: int
           The workspace ID.