databricks-sdk 0.52.0__py3-none-any.whl → 0.54.0__py3-none-any.whl

databricks/sdk/service/settings.py

@@ -65,6 +65,49 @@ class AccountIpAccessEnable:
         )
 
 
+@dataclass
+class AccountNetworkPolicy:
+    account_id: Optional[str] = None
+    """The associated account ID for this Network Policy object."""
+
+    egress: Optional[NetworkPolicyEgress] = None
+    """The network policies applying for egress traffic."""
+
+    network_policy_id: Optional[str] = None
+    """The unique identifier for the network policy."""
+
+    def as_dict(self) -> dict:
+        """Serializes the AccountNetworkPolicy 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.egress:
+            body["egress"] = self.egress.as_dict()
+        if self.network_policy_id is not None:
+            body["network_policy_id"] = self.network_policy_id
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AccountNetworkPolicy into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.account_id is not None:
+            body["account_id"] = self.account_id
+        if self.egress:
+            body["egress"] = self.egress
+        if self.network_policy_id is not None:
+            body["network_policy_id"] = self.network_policy_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> AccountNetworkPolicy:
+        """Deserializes the AccountNetworkPolicy from a dictionary."""
+        return cls(
+            account_id=d.get("account_id", None),
+            egress=_from_dict(d, "egress", NetworkPolicyEgress),
+            network_policy_id=d.get("network_policy_id", None),
+        )
+
+
 @dataclass
 class AibiDashboardEmbeddingAccessPolicy:
     access_policy_type: AibiDashboardEmbeddingAccessPolicyAccessPolicyType
@@ -1405,6 +1448,38 @@ class DeleteDisableLegacyFeaturesResponse:
         return cls(etag=d.get("etag", None))
 
 
+@dataclass
+class DeleteLlmProxyPartnerPoweredWorkspaceResponse:
+    """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 DeleteLlmProxyPartnerPoweredWorkspaceResponse 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 DeleteLlmProxyPartnerPoweredWorkspaceResponse 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]) -> DeleteLlmProxyPartnerPoweredWorkspaceResponse:
+        """Deserializes the DeleteLlmProxyPartnerPoweredWorkspaceResponse from a dictionary."""
+        return cls(etag=d.get("etag", None))
+
+
 @dataclass
 class DeleteNetworkConnectivityConfigurationResponse:
     def as_dict(self) -> dict:
@@ -1423,6 +1498,24 @@ class DeleteNetworkConnectivityConfigurationResponse:
         return cls()
 
 
+@dataclass
+class DeleteNetworkPolicyRpcResponse:
+    def as_dict(self) -> dict:
+        """Serializes the DeleteNetworkPolicyRpcResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeleteNetworkPolicyRpcResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> DeleteNetworkPolicyRpcResponse:
+        """Deserializes the DeleteNetworkPolicyRpcResponse from a dictionary."""
+        return cls()
+
+
 @dataclass
 class DeletePersonalComputeSettingResponse:
     """The etag is returned."""
@@ -1963,6 +2056,257 @@ class EgressNetworkPolicyInternetAccessPolicyStorageDestinationStorageDestinatio
     GOOGLE_CLOUD_STORAGE = "GOOGLE_CLOUD_STORAGE"
 
 
+@dataclass
+class EgressNetworkPolicyNetworkAccessPolicy:
+    restriction_mode: EgressNetworkPolicyNetworkAccessPolicyRestrictionMode
+    """The restriction mode that controls how serverless workloads can access the internet."""
+
+    allowed_internet_destinations: Optional[List[EgressNetworkPolicyNetworkAccessPolicyInternetDestination]] = None
+    """List of internet destinations that serverless workloads are allowed to access when in
+    RESTRICTED_ACCESS mode."""
+
+    allowed_storage_destinations: Optional[List[EgressNetworkPolicyNetworkAccessPolicyStorageDestination]] = None
+    """List of storage destinations that serverless workloads are allowed to access when in
+    RESTRICTED_ACCESS mode."""
+
+    policy_enforcement: Optional[EgressNetworkPolicyNetworkAccessPolicyPolicyEnforcement] = None
+    """Optional. When policy_enforcement is not provided, we default to ENFORCE_MODE_ALL_SERVICES"""
+
+    def as_dict(self) -> dict:
+        """Serializes the EgressNetworkPolicyNetworkAccessPolicy into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.allowed_internet_destinations:
+            body["allowed_internet_destinations"] = [v.as_dict() for v in self.allowed_internet_destinations]
+        if self.allowed_storage_destinations:
+            body["allowed_storage_destinations"] = [v.as_dict() for v in self.allowed_storage_destinations]
+        if self.policy_enforcement:
+            body["policy_enforcement"] = self.policy_enforcement.as_dict()
+        if self.restriction_mode is not None:
+            body["restriction_mode"] = self.restriction_mode.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EgressNetworkPolicyNetworkAccessPolicy into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.allowed_internet_destinations:
+            body["allowed_internet_destinations"] = self.allowed_internet_destinations
+        if self.allowed_storage_destinations:
+            body["allowed_storage_destinations"] = self.allowed_storage_destinations
+        if self.policy_enforcement:
+            body["policy_enforcement"] = self.policy_enforcement
+        if self.restriction_mode is not None:
+            body["restriction_mode"] = self.restriction_mode
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> EgressNetworkPolicyNetworkAccessPolicy:
+        """Deserializes the EgressNetworkPolicyNetworkAccessPolicy from a dictionary."""
+        return cls(
+            allowed_internet_destinations=_repeated_dict(
+                d, "allowed_internet_destinations", EgressNetworkPolicyNetworkAccessPolicyInternetDestination
+            ),
+            allowed_storage_destinations=_repeated_dict(
+                d, "allowed_storage_destinations", EgressNetworkPolicyNetworkAccessPolicyStorageDestination
+            ),
+            policy_enforcement=_from_dict(
+                d, "policy_enforcement", EgressNetworkPolicyNetworkAccessPolicyPolicyEnforcement
+            ),
+            restriction_mode=_enum(d, "restriction_mode", EgressNetworkPolicyNetworkAccessPolicyRestrictionMode),
+        )
+
+
+@dataclass
+class EgressNetworkPolicyNetworkAccessPolicyInternetDestination:
+    """Users can specify accessible internet destinations when outbound access is restricted. We only
+    support DNS_NAME (FQDN format) destinations for the time being. Going forward we may extend
+    support to host names and IP addresses."""
+
+    destination: Optional[str] = None
+    """The internet destination to which access will be allowed. Format dependent on the destination
+    type."""
+
+    internet_destination_type: Optional[
+        EgressNetworkPolicyNetworkAccessPolicyInternetDestinationInternetDestinationType
+    ] = None
+    """The type of internet destination. Currently only DNS_NAME is supported."""
+
+    def as_dict(self) -> dict:
+        """Serializes the EgressNetworkPolicyNetworkAccessPolicyInternetDestination into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.destination is not None:
+            body["destination"] = self.destination
+        if self.internet_destination_type is not None:
+            body["internet_destination_type"] = self.internet_destination_type.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EgressNetworkPolicyNetworkAccessPolicyInternetDestination into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.destination is not None:
+            body["destination"] = self.destination
+        if self.internet_destination_type is not None:
+            body["internet_destination_type"] = self.internet_destination_type
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> EgressNetworkPolicyNetworkAccessPolicyInternetDestination:
+        """Deserializes the EgressNetworkPolicyNetworkAccessPolicyInternetDestination from a dictionary."""
+        return cls(
+            destination=d.get("destination", None),
+            internet_destination_type=_enum(
+                d,
+                "internet_destination_type",
+                EgressNetworkPolicyNetworkAccessPolicyInternetDestinationInternetDestinationType,
+            ),
+        )
+
+
+class EgressNetworkPolicyNetworkAccessPolicyInternetDestinationInternetDestinationType(Enum):
+
+    DNS_NAME = "DNS_NAME"
+
+
+@dataclass
+class EgressNetworkPolicyNetworkAccessPolicyPolicyEnforcement:
+    dry_run_mode_product_filter: Optional[
+        List[EgressNetworkPolicyNetworkAccessPolicyPolicyEnforcementDryRunModeProductFilter]
+    ] = None
+    """When empty, it means dry run for all products. When non-empty, it means dry run for specific
+    products and for the other products, they will run in enforced mode."""
+
+    enforcement_mode: Optional[EgressNetworkPolicyNetworkAccessPolicyPolicyEnforcementEnforcementMode] = None
+    """The mode of policy enforcement. ENFORCED blocks traffic that violates policy, while DRY_RUN only
+    logs violations without blocking. When not specified, defaults to ENFORCED."""
+
+    def as_dict(self) -> dict:
+        """Serializes the EgressNetworkPolicyNetworkAccessPolicyPolicyEnforcement into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.dry_run_mode_product_filter:
+            body["dry_run_mode_product_filter"] = [v.value for v in self.dry_run_mode_product_filter]
+        if self.enforcement_mode is not None:
+            body["enforcement_mode"] = self.enforcement_mode.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EgressNetworkPolicyNetworkAccessPolicyPolicyEnforcement into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.dry_run_mode_product_filter:
+            body["dry_run_mode_product_filter"] = self.dry_run_mode_product_filter
+        if self.enforcement_mode is not None:
+            body["enforcement_mode"] = self.enforcement_mode
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> EgressNetworkPolicyNetworkAccessPolicyPolicyEnforcement:
+        """Deserializes the EgressNetworkPolicyNetworkAccessPolicyPolicyEnforcement from a dictionary."""
+        return cls(
+            dry_run_mode_product_filter=_repeated_enum(
+                d,
+                "dry_run_mode_product_filter",
+                EgressNetworkPolicyNetworkAccessPolicyPolicyEnforcementDryRunModeProductFilter,
+            ),
+            enforcement_mode=_enum(
+                d, "enforcement_mode", EgressNetworkPolicyNetworkAccessPolicyPolicyEnforcementEnforcementMode
+            ),
+        )
+
+
+class EgressNetworkPolicyNetworkAccessPolicyPolicyEnforcementDryRunModeProductFilter(Enum):
+    """The values should match the list of workloads used in networkconfig.proto"""
+
+    DBSQL = "DBSQL"
+    ML_SERVING = "ML_SERVING"
+
+
+class EgressNetworkPolicyNetworkAccessPolicyPolicyEnforcementEnforcementMode(Enum):
+
+    DRY_RUN = "DRY_RUN"
+    ENFORCED = "ENFORCED"
+
+
+class EgressNetworkPolicyNetworkAccessPolicyRestrictionMode(Enum):
+    """At which level can Databricks and Databricks managed compute access Internet. FULL_ACCESS:
+    Databricks can access Internet. No blocking rules will apply. RESTRICTED_ACCESS: Databricks can
+    only access explicitly allowed internet and storage destinations, as well as UC connections and
+    external locations."""
+
+    FULL_ACCESS = "FULL_ACCESS"
+    RESTRICTED_ACCESS = "RESTRICTED_ACCESS"
+
+
+@dataclass
+class EgressNetworkPolicyNetworkAccessPolicyStorageDestination:
+    """Users can specify accessible storage destinations."""
+
+    azure_storage_account: Optional[str] = None
+    """The Azure storage account name."""
+
+    azure_storage_service: Optional[str] = None
+    """The Azure storage service type (blob, dfs, etc.)."""
+
+    bucket_name: Optional[str] = None
+
+    region: Optional[str] = None
+    """The region of the S3 bucket."""
+
+    storage_destination_type: Optional[
+        EgressNetworkPolicyNetworkAccessPolicyStorageDestinationStorageDestinationType
+    ] = None
+    """The type of storage destination."""
+
+    def as_dict(self) -> dict:
+        """Serializes the EgressNetworkPolicyNetworkAccessPolicyStorageDestination into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.azure_storage_account is not None:
+            body["azure_storage_account"] = self.azure_storage_account
+        if self.azure_storage_service is not None:
+            body["azure_storage_service"] = self.azure_storage_service
+        if self.bucket_name is not None:
+            body["bucket_name"] = self.bucket_name
+        if self.region is not None:
+            body["region"] = self.region
+        if self.storage_destination_type is not None:
+            body["storage_destination_type"] = self.storage_destination_type.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EgressNetworkPolicyNetworkAccessPolicyStorageDestination into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.azure_storage_account is not None:
+            body["azure_storage_account"] = self.azure_storage_account
+        if self.azure_storage_service is not None:
+            body["azure_storage_service"] = self.azure_storage_service
+        if self.bucket_name is not None:
+            body["bucket_name"] = self.bucket_name
+        if self.region is not None:
+            body["region"] = self.region
+        if self.storage_destination_type is not None:
+            body["storage_destination_type"] = self.storage_destination_type
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> EgressNetworkPolicyNetworkAccessPolicyStorageDestination:
+        """Deserializes the EgressNetworkPolicyNetworkAccessPolicyStorageDestination from a dictionary."""
+        return cls(
+            azure_storage_account=d.get("azure_storage_account", None),
+            azure_storage_service=d.get("azure_storage_service", None),
+            bucket_name=d.get("bucket_name", None),
+            region=d.get("region", None),
+            storage_destination_type=_enum(
+                d,
+                "storage_destination_type",
+                EgressNetworkPolicyNetworkAccessPolicyStorageDestinationStorageDestinationType,
+            ),
+        )
+
+
+class EgressNetworkPolicyNetworkAccessPolicyStorageDestinationStorageDestinationType(Enum):
+
+    AWS_S3 = "AWS_S3"
+    AZURE_STORAGE = "AZURE_STORAGE"
+    GOOGLE_CLOUD_STORAGE = "GOOGLE_CLOUD_STORAGE"
+
+
 class EgressResourceType(Enum):
     """The target resources that are supported by Network Connectivity Config. Note: some egress types
     can support general types that are not defined in EgressResourceType. E.g.: Azure private
@@ -2803,6 +3147,41 @@ class ListNetworkConnectivityConfigurationsResponse:
         )
 
 
+@dataclass
+class ListNetworkPoliciesResponse:
+    items: Optional[List[AccountNetworkPolicy]] = None
+    """List of network policies."""
+
+    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 ListNetworkPoliciesResponse 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 ListNetworkPoliciesResponse 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]) -> ListNetworkPoliciesResponse:
+        """Deserializes the ListNetworkPoliciesResponse from a dictionary."""
+        return cls(
+            items=_repeated_dict(d, "items", AccountNetworkPolicy), next_page_token=d.get("next_page_token", None)
+        )
+
+
 @dataclass
 class ListNotificationDestinationsResponse:
     next_page_token: Optional[str] = None
@@ -2943,17 +3322,167 @@ class ListType(Enum):
 
 
 @dataclass
-class MicrosoftTeamsConfig:
-    url: Optional[str] = None
-    """[Input-Only] URL for Microsoft Teams."""
-
-    url_set: Optional[bool] = None
-    """[Output-Only] Whether URL is set."""
+class LlmProxyPartnerPoweredAccount:
+    boolean_val: BooleanMessage
 
-    def as_dict(self) -> dict:
-        """Serializes the MicrosoftTeamsConfig into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.url is not None:
+    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 LlmProxyPartnerPoweredAccount 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 LlmProxyPartnerPoweredAccount 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]) -> LlmProxyPartnerPoweredAccount:
+        """Deserializes the LlmProxyPartnerPoweredAccount 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 LlmProxyPartnerPoweredEnforce:
+    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 LlmProxyPartnerPoweredEnforce 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 LlmProxyPartnerPoweredEnforce 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]) -> LlmProxyPartnerPoweredEnforce:
+        """Deserializes the LlmProxyPartnerPoweredEnforce 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 LlmProxyPartnerPoweredWorkspace:
+    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 LlmProxyPartnerPoweredWorkspace 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 LlmProxyPartnerPoweredWorkspace 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]) -> LlmProxyPartnerPoweredWorkspace:
+        """Deserializes the LlmProxyPartnerPoweredWorkspace 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 MicrosoftTeamsConfig:
+    url: Optional[str] = None
+    """[Input-Only] URL for Microsoft Teams."""
+
+    url_set: Optional[bool] = None
+    """[Output-Only] Whether URL is set."""
+
+    def as_dict(self) -> dict:
+        """Serializes the MicrosoftTeamsConfig into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.url is not None:
             body["url"] = self.url
         if self.url_set is not None:
             body["url_set"] = self.url_set
@@ -3372,6 +3901,37 @@ class NetworkConnectivityConfiguration:
         )
 
 
+@dataclass
+class NetworkPolicyEgress:
+    """The network policies applying for egress traffic. This message is used by the UI/REST API. We
+    translate this message to the format expected by the dataplane in Lakehouse Network Manager (for
+    the format expected by the dataplane, see networkconfig.textproto). This policy should be
+    consistent with [[com.databricks.api.proto.settingspolicy.EgressNetworkPolicy]]. Details see
+    API-design: https://docs.google.com/document/d/1DKWO_FpZMCY4cF2O62LpwII1lx8gsnDGG-qgE3t3TOA/"""
+
+    network_access: Optional[EgressNetworkPolicyNetworkAccessPolicy] = None
+    """The access policy enforced for egress traffic to the internet."""
+
+    def as_dict(self) -> dict:
+        """Serializes the NetworkPolicyEgress into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.network_access:
+            body["network_access"] = self.network_access.as_dict()
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the NetworkPolicyEgress into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.network_access:
+            body["network_access"] = self.network_access
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> NetworkPolicyEgress:
+        """Deserializes the NetworkPolicyEgress from a dictionary."""
+        return cls(network_access=_from_dict(d, "network_access", EgressNetworkPolicyNetworkAccessPolicy))
+
+
 @dataclass
 class NotificationDestination:
     config: Optional[Config] = None
@@ -5113,54 +5673,65 @@ class UpdateIpAccessList:
 
 
 @dataclass
-class UpdateNotificationDestinationRequest:
-    config: Optional[Config] = None
-    """The configuration for the notification destination. Must wrap EXACTLY one of the nested configs."""
+class UpdateLlmProxyPartnerPoweredAccountRequest:
+    """Details required to update a setting."""
 
-    display_name: Optional[str] = None
-    """The display name for the notification destination."""
+    allow_missing: bool
+    """This should always be set to true for Settings API. Added for AIP compliance."""
 
-    id: Optional[str] = None
-    """UUID identifying notification destination."""
+    setting: LlmProxyPartnerPoweredAccount
+
+    field_mask: str
+    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
+    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
+    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
+    as only the entire collection field can be specified. Field names must exactly match the
+    resource field names.
+    
+    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
+    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
+    API changes in the future."""
 
     def as_dict(self) -> dict:
-        """Serializes the UpdateNotificationDestinationRequest into a dictionary suitable for use as a JSON request body."""
+        """Serializes the UpdateLlmProxyPartnerPoweredAccountRequest into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.config:
-            body["config"] = self.config.as_dict()
-        if self.display_name is not None:
-            body["display_name"] = self.display_name
-        if self.id is not None:
-            body["id"] = self.id
+        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 UpdateNotificationDestinationRequest into a shallow dictionary of its immediate attributes."""
+        """Serializes the UpdateLlmProxyPartnerPoweredAccountRequest into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.config:
-            body["config"] = self.config
-        if self.display_name is not None:
-            body["display_name"] = self.display_name
-        if self.id is not None:
-            body["id"] = self.id
+        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]) -> UpdateNotificationDestinationRequest:
-        """Deserializes the UpdateNotificationDestinationRequest from a dictionary."""
+    def from_dict(cls, d: Dict[str, Any]) -> UpdateLlmProxyPartnerPoweredAccountRequest:
+        """Deserializes the UpdateLlmProxyPartnerPoweredAccountRequest from a dictionary."""
         return cls(
-            config=_from_dict(d, "config", Config), display_name=d.get("display_name", None), id=d.get("id", None)
+            allow_missing=d.get("allow_missing", None),
+            field_mask=d.get("field_mask", None),
+            setting=_from_dict(d, "setting", LlmProxyPartnerPoweredAccount),
         )
 
 
 @dataclass
-class UpdatePersonalComputeSettingRequest:
+class UpdateLlmProxyPartnerPoweredEnforceRequest:
     """Details required to update a setting."""
 
     allow_missing: bool
     """This should always be set to true for Settings API. Added for AIP compliance."""
 
-    setting: PersonalComputeSetting
+    setting: LlmProxyPartnerPoweredEnforce
 
     field_mask: str
     """The field mask must be a single string, with multiple fields separated by commas (no spaces).
@@ -5174,7 +5745,7 @@ class UpdatePersonalComputeSettingRequest:
     API changes in the future."""
 
     def as_dict(self) -> dict:
-        """Serializes the UpdatePersonalComputeSettingRequest into a dictionary suitable for use as a JSON request body."""
+        """Serializes the UpdateLlmProxyPartnerPoweredEnforceRequest into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.allow_missing is not None:
             body["allow_missing"] = self.allow_missing
@@ -5185,7 +5756,7 @@ class UpdatePersonalComputeSettingRequest:
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the UpdatePersonalComputeSettingRequest into a shallow dictionary of its immediate attributes."""
+        """Serializes the UpdateLlmProxyPartnerPoweredEnforceRequest into a shallow dictionary of its immediate attributes."""
         body = {}
         if self.allow_missing is not None:
             body["allow_missing"] = self.allow_missing
@@ -5196,43 +5767,188 @@ class UpdatePersonalComputeSettingRequest:
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> UpdatePersonalComputeSettingRequest:
-        """Deserializes the UpdatePersonalComputeSettingRequest from a dictionary."""
+    def from_dict(cls, d: Dict[str, Any]) -> UpdateLlmProxyPartnerPoweredEnforceRequest:
+        """Deserializes the UpdateLlmProxyPartnerPoweredEnforceRequest from a dictionary."""
         return cls(
             allow_missing=d.get("allow_missing", None),
             field_mask=d.get("field_mask", None),
-            setting=_from_dict(d, "setting", PersonalComputeSetting),
+            setting=_from_dict(d, "setting", LlmProxyPartnerPoweredEnforce),
         )
 
 
 @dataclass
-class UpdatePrivateEndpointRule:
-    """Properties of the new private endpoint rule. Note that you must approve the endpoint in Azure
-    portal after initialization."""
+class UpdateLlmProxyPartnerPoweredWorkspaceRequest:
+    """Details required to update a setting."""
 
-    domain_names: Optional[List[str]] = None
-    """Only used by private endpoints to customer-managed resources.
+    allow_missing: bool
+    """This should always be set to true for Settings API. Added for AIP compliance."""
+
+    setting: LlmProxyPartnerPoweredWorkspace
+
+    field_mask: str
+    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
+    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
+    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
+    as only the entire collection field can be specified. Field names must exactly match the
+    resource field names.
     
-    Domain names of target private link service. When updating this field, the full list of target
-    domain_names must be specified."""
+    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 UpdatePrivateEndpointRule into a dictionary suitable for use as a JSON request body."""
+        """Serializes the UpdateLlmProxyPartnerPoweredWorkspaceRequest 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.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 UpdatePrivateEndpointRule into a shallow dictionary of its immediate attributes."""
+        """Serializes the UpdateLlmProxyPartnerPoweredWorkspaceRequest into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.domain_names:
-            body["domain_names"] = self.domain_names
+        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]) -> UpdatePrivateEndpointRule:
-        """Deserializes the UpdatePrivateEndpointRule from a dictionary."""
+    def from_dict(cls, d: Dict[str, Any]) -> UpdateLlmProxyPartnerPoweredWorkspaceRequest:
+        """Deserializes the UpdateLlmProxyPartnerPoweredWorkspaceRequest from a dictionary."""
+        return cls(
+            allow_missing=d.get("allow_missing", None),
+            field_mask=d.get("field_mask", None),
+            setting=_from_dict(d, "setting", LlmProxyPartnerPoweredWorkspace),
+        )
+
+
+@dataclass
+class UpdateNotificationDestinationRequest:
+    config: Optional[Config] = None
+    """The configuration for the notification destination. Must wrap EXACTLY one of the nested configs."""
+
+    display_name: Optional[str] = None
+    """The display name for the notification destination."""
+
+    id: Optional[str] = None
+    """UUID identifying notification destination."""
+
+    def as_dict(self) -> dict:
+        """Serializes the UpdateNotificationDestinationRequest into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.config:
+            body["config"] = self.config.as_dict()
+        if self.display_name is not None:
+            body["display_name"] = self.display_name
+        if self.id is not None:
+            body["id"] = self.id
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateNotificationDestinationRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.config:
+            body["config"] = self.config
+        if self.display_name is not None:
+            body["display_name"] = self.display_name
+        if self.id is not None:
+            body["id"] = self.id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> UpdateNotificationDestinationRequest:
+        """Deserializes the UpdateNotificationDestinationRequest from a dictionary."""
+        return cls(
+            config=_from_dict(d, "config", Config), display_name=d.get("display_name", None), id=d.get("id", None)
+        )
+
+
+@dataclass
+class UpdatePersonalComputeSettingRequest:
+    """Details required to update a setting."""
+
+    allow_missing: bool
+    """This should always be set to true for Settings API. Added for AIP compliance."""
+
+    setting: PersonalComputeSetting
+
+    field_mask: str
+    """The field mask must be a single string, with multiple fields separated by commas (no spaces).
+    The field path is relative to the resource object, using a dot (`.`) to navigate sub-fields
+    (e.g., `author.given_name`). Specification of elements in sequence or map fields is not allowed,
+    as only the entire collection field can be specified. Field names must exactly match the
+    resource field names.
+    
+    A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
+    fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the
+    API changes in the future."""
+
+    def as_dict(self) -> dict:
+        """Serializes the UpdatePersonalComputeSettingRequest into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.allow_missing is not None:
+            body["allow_missing"] = self.allow_missing
+        if self.field_mask is not None:
+            body["field_mask"] = self.field_mask
+        if self.setting:
+            body["setting"] = self.setting.as_dict()
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdatePersonalComputeSettingRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.allow_missing is not None:
+            body["allow_missing"] = self.allow_missing
+        if self.field_mask is not None:
+            body["field_mask"] = self.field_mask
+        if self.setting:
+            body["setting"] = self.setting
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> UpdatePersonalComputeSettingRequest:
+        """Deserializes the UpdatePersonalComputeSettingRequest from a dictionary."""
+        return cls(
+            allow_missing=d.get("allow_missing", None),
+            field_mask=d.get("field_mask", None),
+            setting=_from_dict(d, "setting", PersonalComputeSetting),
+        )
+
+
+@dataclass
+class UpdatePrivateEndpointRule:
+    """Properties of the new private endpoint rule. Note that you must approve the endpoint in Azure
+    portal after initialization."""
+
+    domain_names: Optional[List[str]] = None
+    """Only used by private endpoints to customer-managed resources.
+    
+    Domain names of target private link service. When updating this field, the full list of target
+    domain_names must be specified."""
+
+    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]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdatePrivateEndpointRule into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.domain_names:
+            body["domain_names"] = self.domain_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))
 
 
@@ -5309,6 +6025,40 @@ class UpdateRestrictWorkspaceAdminsSettingRequest:
 WorkspaceConf = Dict[str, str]
 
 
+@dataclass
+class WorkspaceNetworkOption:
+    network_policy_id: Optional[str] = None
+    """The network policy ID to apply to the workspace. This controls the network access rules for all
+    serverless compute resources in the workspace. Each workspace can only be linked to one policy
+    at a time. If no policy is explicitly assigned, the workspace will use 'default-policy'."""
+
+    workspace_id: Optional[int] = None
+    """The workspace ID."""
+
+    def as_dict(self) -> dict:
+        """Serializes the WorkspaceNetworkOption into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.network_policy_id is not None:
+            body["network_policy_id"] = self.network_policy_id
+        if self.workspace_id is not None:
+            body["workspace_id"] = self.workspace_id
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the WorkspaceNetworkOption into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.network_policy_id is not None:
+            body["network_policy_id"] = self.network_policy_id
+        if self.workspace_id is not None:
+            body["workspace_id"] = self.workspace_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> WorkspaceNetworkOption:
+        """Deserializes the WorkspaceNetworkOption from a dictionary."""
+        return cls(network_policy_id=d.get("network_policy_id", None), workspace_id=d.get("workspace_id", None))
+
+
 class AccountIpAccessListsAPI:
     """The Accounts IP Access List API enables account admins to configure IP access lists for access to the
     account console.
@@ -5559,6 +6309,8 @@ class AccountSettingsAPI:
         self._disable_legacy_features = DisableLegacyFeaturesAPI(self._api)
         self._enable_ip_access_lists = EnableIpAccessListsAPI(self._api)
         self._esm_enablement_account = EsmEnablementAccountAPI(self._api)
+        self._llm_proxy_partner_powered_account = LlmProxyPartnerPoweredAccountAPI(self._api)
+        self._llm_proxy_partner_powered_enforce = LlmProxyPartnerPoweredEnforceAPI(self._api)
         self._personal_compute = PersonalComputeAPI(self._api)
 
     @property
@@ -5581,6 +6333,16 @@ class AccountSettingsAPI:
         """The enhanced security monitoring setting at the account level controls whether to enable the feature on new workspaces."""
         return self._esm_enablement_account
 
+    @property
+    def llm_proxy_partner_powered_account(self) -> LlmProxyPartnerPoweredAccountAPI:
+        """Determines if partner powered models are enabled or not for a specific account."""
+        return self._llm_proxy_partner_powered_account
+
+    @property
+    def llm_proxy_partner_powered_enforce(self) -> LlmProxyPartnerPoweredEnforceAPI:
+        """Determines if the account-level partner-powered setting value is enforced upon the workspace-level partner-powered setting."""
+        return self._llm_proxy_partner_powered_enforce
+
     @property
     def personal_compute(self) -> PersonalComputeAPI:
         """The Personal Compute enablement setting lets you control which users can use the Personal Compute default policy to create compute resources."""
@@ -6316,8 +7078,14 @@ class DisableLegacyAccessAPI:
 
 
 class DisableLegacyDbfsAPI:
-    """When this setting is on, access to DBFS root and DBFS mounts is disallowed (as well as creation of new
-    mounts). When the setting is off, all DBFS functionality is enabled"""
+    """Disabling legacy DBFS has the following implications:
+
+    1. Access to DBFS root and DBFS mounts is disallowed (as well as the creation of new mounts). 2. Disables
+    Databricks Runtime versions prior to 13.3LTS.
+
+    When the setting is off, all DBFS functionality is enabled and no restrictions are imposed on Databricks
+    Runtime versions. This setting can take up to 20 minutes to take effect and requires a manual restart of
+    all-purpose compute clusters and SQL warehouses."""
 
     def __init__(self, api_client):
         self._api = api_client
@@ -7219,6 +7987,268 @@ class IpAccessListsAPI:
         self._api.do("PATCH", f"/api/2.0/ip-access-lists/{ip_access_list_id}", body=body, headers=headers)
 
 
+class LlmProxyPartnerPoweredAccountAPI:
+    """Determines if partner powered models are enabled or not for a specific account"""
+
+    def __init__(self, api_client):
+        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.
+
+        :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:`LlmProxyPartnerPoweredAccount`
+        """
+
+        query = {}
+        if etag is not None:
+            query["etag"] = etag
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do(
+            "GET",
+            f"/api/2.0/accounts/{self._api.account_id}/settings/types/llm_proxy_partner_powered/names/default",
+            query=query,
+            headers=headers,
+        )
+        return LlmProxyPartnerPoweredAccount.from_dict(res)
+
+    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.
+
+        :param allow_missing: bool
+          This should always be set to true for Settings API. Added for AIP compliance.
+        :param setting: :class:`LlmProxyPartnerPoweredAccount`
+        :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:`LlmProxyPartnerPoweredAccount`
+        """
+        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",
+            f"/api/2.0/accounts/{self._api.account_id}/settings/types/llm_proxy_partner_powered/names/default",
+            body=body,
+            headers=headers,
+        )
+        return LlmProxyPartnerPoweredAccount.from_dict(res)
+
+
+class LlmProxyPartnerPoweredEnforceAPI:
+    """Determines if the account-level partner-powered setting value is enforced upon the workspace-level
+    partner-powered setting"""
+
+    def __init__(self, api_client):
+        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.
+
+        :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:`LlmProxyPartnerPoweredEnforce`
+        """
+
+        query = {}
+        if etag is not None:
+            query["etag"] = etag
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do(
+            "GET",
+            f"/api/2.0/accounts/{self._api.account_id}/settings/types/llm_proxy_partner_powered_enforce/names/default",
+            query=query,
+            headers=headers,
+        )
+        return LlmProxyPartnerPoweredEnforce.from_dict(res)
+
+    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.
+
+        :param allow_missing: bool
+          This should always be set to true for Settings API. Added for AIP compliance.
+        :param setting: :class:`LlmProxyPartnerPoweredEnforce`
+        :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:`LlmProxyPartnerPoweredEnforce`
+        """
+        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",
+            f"/api/2.0/accounts/{self._api.account_id}/settings/types/llm_proxy_partner_powered_enforce/names/default",
+            body=body,
+            headers=headers,
+        )
+        return LlmProxyPartnerPoweredEnforce.from_dict(res)
+
+
+class LlmProxyPartnerPoweredWorkspaceAPI:
+    """Determines if partner powered models are enabled or not for a specific workspace"""
+
+    def __init__(self, api_client):
+        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.
+
+        :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:`DeleteLlmProxyPartnerPoweredWorkspaceResponse`
+        """
+
+        query = {}
+        if etag is not None:
+            query["etag"] = etag
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do(
+            "DELETE", "/api/2.0/settings/types/llm_proxy_partner_powered/names/default", query=query, headers=headers
+        )
+        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.
+
+        :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:`LlmProxyPartnerPoweredWorkspace`
+        """
+
+        query = {}
+        if etag is not None:
+            query["etag"] = etag
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do(
+            "GET", "/api/2.0/settings/types/llm_proxy_partner_powered/names/default", query=query, headers=headers
+        )
+        return LlmProxyPartnerPoweredWorkspace.from_dict(res)
+
+    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.
+
+        :param allow_missing: bool
+          This should always be set to true for Settings API. Added for AIP compliance.
+        :param setting: :class:`LlmProxyPartnerPoweredWorkspace`
+        :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:`LlmProxyPartnerPoweredWorkspace`
+        """
+        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/llm_proxy_partner_powered/names/default", body=body, headers=headers
+        )
+        return LlmProxyPartnerPoweredWorkspace.from_dict(res)
+
+
 class NetworkConnectivityAPI:
     """These APIs provide configurations for the network connectivity of your workspaces for serverless compute
     resources. This API provides stable subnets for your workspace so that you can configure your firewalls on
@@ -7519,6 +8549,134 @@ class NetworkConnectivityAPI:
         return NccAzurePrivateEndpointRule.from_dict(res)
 
 
+class NetworkPoliciesAPI:
+    """These APIs manage network policies for this account. Network policies control which network destinations
+    can be accessed from the Databricks environment. Each Databricks account includes a default policy named
+    'default-policy'. 'default-policy' is associated with any workspace lacking an explicit network policy
+    assignment, and is automatically associated with each newly created workspace. 'default-policy' is
+    reserved and cannot be deleted, but it can be updated to customize the default network access rules for
+    your account."""
+
+    def __init__(self, api_client):
+        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
+        environment.
+
+        :param network_policy: :class:`AccountNetworkPolicy`
+
+        :returns: :class:`AccountNetworkPolicy`
+        """
+        body = network_policy.as_dict()
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do(
+            "POST", f"/api/2.0/accounts/{self._api.account_id}/network-policies", body=body, headers=headers
+        )
+        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'.
+
+        :param network_policy_id: str
+          The unique identifier of the network policy to delete.
+
+
+        """
+
+        headers = {
+            "Accept": "application/json",
+        }
+
+        self._api.do(
+            "DELETE", f"/api/2.0/accounts/{self._api.account_id}/network-policies/{network_policy_id}", headers=headers
+        )
+
+    def get_network_policy_rpc(self, network_policy_id: str) -> AccountNetworkPolicy:
+        """Get a network policy.
+
+        Gets a network policy.
+
+        :param network_policy_id: str
+          The unique identifier of the network policy to retrieve.
+
+        :returns: :class:`AccountNetworkPolicy`
+        """
+
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do(
+            "GET", f"/api/2.0/accounts/{self._api.account_id}/network-policies/{network_policy_id}", headers=headers
+        )
+        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.
+
+        :param page_token: str (optional)
+          Pagination token to go to next page based on previous query.
+
+        :returns: Iterator over :class:`AccountNetworkPolicy`
+        """
+
+        query = {}
+        if page_token is not None:
+            query["page_token"] = page_token
+        headers = {
+            "Accept": "application/json",
+        }
+
+        while True:
+            json = self._api.do(
+                "GET", f"/api/2.0/accounts/{self._api.account_id}/network-policies", query=query, headers=headers
+            )
+            if "items" in json:
+                for v in json["items"]:
+                    yield AccountNetworkPolicy.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_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.
+
+        :param network_policy_id: str
+          The unique identifier for the network policy.
+        :param network_policy: :class:`AccountNetworkPolicy`
+
+        :returns: :class:`AccountNetworkPolicy`
+        """
+        body = network_policy.as_dict()
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do(
+            "PUT",
+            f"/api/2.0/accounts/{self._api.account_id}/network-policies/{network_policy_id}",
+            body=body,
+            headers=headers,
+        )
+        return AccountNetworkPolicy.from_dict(res)
+
+
 class NotificationDestinationsAPI:
     """The notification destinations API lets you programmatically manage a workspace's notification
     destinations. Notification destinations are used to send notifications for query alerts and jobs to
@@ -7894,6 +9052,7 @@ class SettingsAPI:
         self._enable_notebook_table_clipboard = EnableNotebookTableClipboardAPI(self._api)
         self._enable_results_downloading = EnableResultsDownloadingAPI(self._api)
         self._enhanced_security_monitoring = EnhancedSecurityMonitoringAPI(self._api)
+        self._llm_proxy_partner_powered_workspace = LlmProxyPartnerPoweredWorkspaceAPI(self._api)
         self._restrict_workspace_admins = RestrictWorkspaceAdminsAPI(self._api)
 
     @property
@@ -7928,7 +9087,7 @@ class SettingsAPI:
 
     @property
     def disable_legacy_dbfs(self) -> DisableLegacyDbfsAPI:
-        """When this setting is on, access to DBFS root and DBFS mounts is disallowed (as well as creation of new mounts)."""
+        """Disabling legacy DBFS has the following implications: 1."""
         return self._disable_legacy_dbfs
 
     @property
@@ -7951,6 +9110,11 @@ class SettingsAPI:
         """Controls whether enhanced security monitoring is enabled for the current workspace."""
         return self._enhanced_security_monitoring
 
+    @property
+    def llm_proxy_partner_powered_workspace(self) -> LlmProxyPartnerPoweredWorkspaceAPI:
+        """Determines if partner powered models are enabled or not for a specific workspace."""
+        return self._llm_proxy_partner_powered_workspace
+
     @property
     def restrict_workspace_admins(self) -> RestrictWorkspaceAdminsAPI:
         """The Restrict Workspace Admins setting lets you control the capabilities of workspace admins."""
@@ -8247,3 +9411,64 @@ class WorkspaceConfAPI:
         }
 
         self._api.do("PATCH", "/api/2.0/workspace-conf", body=contents, headers=headers)
+
+
+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."""
+
+    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.
+
+        :param workspace_id: int
+          The workspace ID.
+
+        :returns: :class:`WorkspaceNetworkOption`
+        """
+
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do(
+            "GET", f"/api/2.0/accounts/{self._api.account_id}/workspaces/{workspace_id}/network", headers=headers
+        )
+        return WorkspaceNetworkOption.from_dict(res)
+
+    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.
+
+        :param workspace_id: int
+          The workspace ID.
+        :param workspace_network_option: :class:`WorkspaceNetworkOption`
+
+        :returns: :class:`WorkspaceNetworkOption`
+        """
+        body = workspace_network_option.as_dict()
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do(
+            "PUT",
+            f"/api/2.0/accounts/{self._api.account_id}/workspaces/{workspace_id}/network",
+            body=body,
+            headers=headers,
+        )
+        return WorkspaceNetworkOption.from_dict(res)