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

databricks/sdk/__init__.py

@@ -5,7 +5,6 @@ from typing import Optional
 
 import databricks.sdk.core as client
 import databricks.sdk.dbutils as dbutils
-import databricks.sdk.service as service
 from databricks.sdk import azure
 from databricks.sdk.credentials_provider import CredentialsStrategy
 from databricks.sdk.data_plane import DataPlaneTokenSource
@@ -14,6 +13,26 @@ from databricks.sdk.mixins.files import DbfsExt, FilesExt
 from databricks.sdk.mixins.jobs import JobsExt
 from databricks.sdk.mixins.open_ai_client import ServingEndpointsExt
 from databricks.sdk.mixins.workspace import WorkspaceExt
+from databricks.sdk.service import apps as pkg_apps
+from databricks.sdk.service import billing as pkg_billing
+from databricks.sdk.service import catalog as pkg_catalog
+from databricks.sdk.service import cleanrooms as pkg_cleanrooms
+from databricks.sdk.service import compute as pkg_compute
+from databricks.sdk.service import dashboards as pkg_dashboards
+from databricks.sdk.service import files as pkg_files
+from databricks.sdk.service import iam as pkg_iam
+from databricks.sdk.service import jobs as pkg_jobs
+from databricks.sdk.service import marketplace as pkg_marketplace
+from databricks.sdk.service import ml as pkg_ml
+from databricks.sdk.service import oauth2 as pkg_oauth2
+from databricks.sdk.service import pipelines as pkg_pipelines
+from databricks.sdk.service import provisioning as pkg_provisioning
+from databricks.sdk.service import serving as pkg_serving
+from databricks.sdk.service import settings as pkg_settings
+from databricks.sdk.service import sharing as pkg_sharing
+from databricks.sdk.service import sql as pkg_sql
+from databricks.sdk.service import vectorsearch as pkg_vectorsearch
+from databricks.sdk.service import workspace as pkg_workspace
 from databricks.sdk.service.apps import AppsAPI
 from databricks.sdk.service.billing import (BillableUsageAPI, BudgetPolicyAPI,
                                             BudgetsAPI, LogDeliveryAPI,
@@ -23,6 +42,7 @@ from databricks.sdk.service.catalog import (AccountMetastoreAssignmentsAPI,
                                             AccountStorageCredentialsAPI,
                                             ArtifactAllowlistsAPI, CatalogsAPI,
                                             ConnectionsAPI, CredentialsAPI,
+                                            DatabaseInstancesAPI,
                                             ExternalLocationsAPI, FunctionsAPI,
                                             GrantsAPI, MetastoresAPI,
                                             ModelVersionsAPI, OnlineTablesAPI,
@@ -89,12 +109,15 @@ from databricks.sdk.service.settings import (
     DisableLegacyDbfsAPI, DisableLegacyFeaturesAPI, EnableExportNotebookAPI,
     EnableIpAccessListsAPI, EnableNotebookTableClipboardAPI,
     EnableResultsDownloadingAPI, EnhancedSecurityMonitoringAPI,
-    EsmEnablementAccountAPI, IpAccessListsAPI, NetworkConnectivityAPI,
-    NotificationDestinationsAPI, PersonalComputeAPI,
+    EsmEnablementAccountAPI, IpAccessListsAPI,
+    LlmProxyPartnerPoweredAccountAPI, LlmProxyPartnerPoweredEnforceAPI,
+    LlmProxyPartnerPoweredWorkspaceAPI, NetworkConnectivityAPI,
+    NetworkPoliciesAPI, NotificationDestinationsAPI, PersonalComputeAPI,
     RestrictWorkspaceAdminsAPI, SettingsAPI, TokenManagementAPI, TokensAPI,
-    WorkspaceConfAPI)
+    WorkspaceConfAPI, WorkspaceNetworkConfigurationAPI)
 from databricks.sdk.service.sharing import (ProvidersAPI,
                                             RecipientActivationAPI,
+                                            RecipientFederationPoliciesAPI,
                                             RecipientsAPI, SharesAPI)
 from databricks.sdk.service.sql import (AlertsAPI, AlertsLegacyAPI,
                                         AlertsV2API, DashboardsAPI,
@@ -205,117 +228,115 @@ class WorkspaceClient:
         self._dbutils = _make_dbutils(self._config)
         self._api_client = client.ApiClient(self._config)
         serving_endpoints = ServingEndpointsExt(self._api_client)
-        self._access_control = service.iam.AccessControlAPI(self._api_client)
-        self._account_access_control_proxy = service.iam.AccountAccessControlProxyAPI(self._api_client)
-        self._alerts = service.sql.AlertsAPI(self._api_client)
-        self._alerts_legacy = service.sql.AlertsLegacyAPI(self._api_client)
-        self._alerts_v2 = service.sql.AlertsV2API(self._api_client)
-        self._apps = service.apps.AppsAPI(self._api_client)
-        self._artifact_allowlists = service.catalog.ArtifactAllowlistsAPI(self._api_client)
-        self._catalogs = service.catalog.CatalogsAPI(self._api_client)
-        self._clean_room_assets = service.cleanrooms.CleanRoomAssetsAPI(self._api_client)
-        self._clean_room_task_runs = service.cleanrooms.CleanRoomTaskRunsAPI(self._api_client)
-        self._clean_rooms = service.cleanrooms.CleanRoomsAPI(self._api_client)
-        self._cluster_policies = service.compute.ClusterPoliciesAPI(self._api_client)
+        self._access_control = pkg_iam.AccessControlAPI(self._api_client)
+        self._account_access_control_proxy = pkg_iam.AccountAccessControlProxyAPI(self._api_client)
+        self._alerts = pkg_sql.AlertsAPI(self._api_client)
+        self._alerts_legacy = pkg_sql.AlertsLegacyAPI(self._api_client)
+        self._alerts_v2 = pkg_sql.AlertsV2API(self._api_client)
+        self._apps = pkg_apps.AppsAPI(self._api_client)
+        self._artifact_allowlists = pkg_catalog.ArtifactAllowlistsAPI(self._api_client)
+        self._catalogs = pkg_catalog.CatalogsAPI(self._api_client)
+        self._clean_room_assets = pkg_cleanrooms.CleanRoomAssetsAPI(self._api_client)
+        self._clean_room_task_runs = pkg_cleanrooms.CleanRoomTaskRunsAPI(self._api_client)
+        self._clean_rooms = pkg_cleanrooms.CleanRoomsAPI(self._api_client)
+        self._cluster_policies = pkg_compute.ClusterPoliciesAPI(self._api_client)
         self._clusters = ClustersExt(self._api_client)
-        self._command_execution = service.compute.CommandExecutionAPI(self._api_client)
-        self._connections = service.catalog.ConnectionsAPI(self._api_client)
-        self._consumer_fulfillments = service.marketplace.ConsumerFulfillmentsAPI(self._api_client)
-        self._consumer_installations = service.marketplace.ConsumerInstallationsAPI(self._api_client)
-        self._consumer_listings = service.marketplace.ConsumerListingsAPI(self._api_client)
-        self._consumer_personalization_requests = service.marketplace.ConsumerPersonalizationRequestsAPI(
-            self._api_client
-        )
-        self._consumer_providers = service.marketplace.ConsumerProvidersAPI(self._api_client)
-        self._credentials = service.catalog.CredentialsAPI(self._api_client)
-        self._credentials_manager = service.settings.CredentialsManagerAPI(self._api_client)
-        self._current_user = service.iam.CurrentUserAPI(self._api_client)
-        self._dashboard_widgets = service.sql.DashboardWidgetsAPI(self._api_client)
-        self._dashboards = service.sql.DashboardsAPI(self._api_client)
-        self._data_sources = service.sql.DataSourcesAPI(self._api_client)
+        self._command_execution = pkg_compute.CommandExecutionAPI(self._api_client)
+        self._connections = pkg_catalog.ConnectionsAPI(self._api_client)
+        self._consumer_fulfillments = pkg_marketplace.ConsumerFulfillmentsAPI(self._api_client)
+        self._consumer_installations = pkg_marketplace.ConsumerInstallationsAPI(self._api_client)
+        self._consumer_listings = pkg_marketplace.ConsumerListingsAPI(self._api_client)
+        self._consumer_personalization_requests = pkg_marketplace.ConsumerPersonalizationRequestsAPI(self._api_client)
+        self._consumer_providers = pkg_marketplace.ConsumerProvidersAPI(self._api_client)
+        self._credentials = pkg_catalog.CredentialsAPI(self._api_client)
+        self._credentials_manager = pkg_settings.CredentialsManagerAPI(self._api_client)
+        self._current_user = pkg_iam.CurrentUserAPI(self._api_client)
+        self._dashboard_widgets = pkg_sql.DashboardWidgetsAPI(self._api_client)
+        self._dashboards = pkg_sql.DashboardsAPI(self._api_client)
+        self._data_sources = pkg_sql.DataSourcesAPI(self._api_client)
+        self._database_instances = pkg_catalog.DatabaseInstancesAPI(self._api_client)
         self._dbfs = DbfsExt(self._api_client)
-        self._dbsql_permissions = service.sql.DbsqlPermissionsAPI(self._api_client)
-        self._experiments = service.ml.ExperimentsAPI(self._api_client)
-        self._external_locations = service.catalog.ExternalLocationsAPI(self._api_client)
+        self._dbsql_permissions = pkg_sql.DbsqlPermissionsAPI(self._api_client)
+        self._experiments = pkg_ml.ExperimentsAPI(self._api_client)
+        self._external_locations = pkg_catalog.ExternalLocationsAPI(self._api_client)
         self._files = _make_files_client(self._api_client, self._config)
-        self._functions = service.catalog.FunctionsAPI(self._api_client)
-        self._genie = service.dashboards.GenieAPI(self._api_client)
-        self._git_credentials = service.workspace.GitCredentialsAPI(self._api_client)
-        self._global_init_scripts = service.compute.GlobalInitScriptsAPI(self._api_client)
-        self._grants = service.catalog.GrantsAPI(self._api_client)
-        self._groups = service.iam.GroupsAPI(self._api_client)
-        self._instance_pools = service.compute.InstancePoolsAPI(self._api_client)
-        self._instance_profiles = service.compute.InstanceProfilesAPI(self._api_client)
-        self._ip_access_lists = service.settings.IpAccessListsAPI(self._api_client)
+        self._functions = pkg_catalog.FunctionsAPI(self._api_client)
+        self._genie = pkg_dashboards.GenieAPI(self._api_client)
+        self._git_credentials = pkg_workspace.GitCredentialsAPI(self._api_client)
+        self._global_init_scripts = pkg_compute.GlobalInitScriptsAPI(self._api_client)
+        self._grants = pkg_catalog.GrantsAPI(self._api_client)
+        self._groups = pkg_iam.GroupsAPI(self._api_client)
+        self._instance_pools = pkg_compute.InstancePoolsAPI(self._api_client)
+        self._instance_profiles = pkg_compute.InstanceProfilesAPI(self._api_client)
+        self._ip_access_lists = pkg_settings.IpAccessListsAPI(self._api_client)
         self._jobs = JobsExt(self._api_client)
-        self._lakeview = service.dashboards.LakeviewAPI(self._api_client)
-        self._lakeview_embedded = service.dashboards.LakeviewEmbeddedAPI(self._api_client)
-        self._libraries = service.compute.LibrariesAPI(self._api_client)
-        self._metastores = service.catalog.MetastoresAPI(self._api_client)
-        self._model_registry = service.ml.ModelRegistryAPI(self._api_client)
-        self._model_versions = service.catalog.ModelVersionsAPI(self._api_client)
-        self._notification_destinations = service.settings.NotificationDestinationsAPI(self._api_client)
-        self._online_tables = service.catalog.OnlineTablesAPI(self._api_client)
-        self._permission_migration = service.iam.PermissionMigrationAPI(self._api_client)
-        self._permissions = service.iam.PermissionsAPI(self._api_client)
-        self._pipelines = service.pipelines.PipelinesAPI(self._api_client)
-        self._policy_compliance_for_clusters = service.compute.PolicyComplianceForClustersAPI(self._api_client)
-        self._policy_compliance_for_jobs = service.jobs.PolicyComplianceForJobsAPI(self._api_client)
-        self._policy_families = service.compute.PolicyFamiliesAPI(self._api_client)
-        self._provider_exchange_filters = service.marketplace.ProviderExchangeFiltersAPI(self._api_client)
-        self._provider_exchanges = service.marketplace.ProviderExchangesAPI(self._api_client)
-        self._provider_files = service.marketplace.ProviderFilesAPI(self._api_client)
-        self._provider_listings = service.marketplace.ProviderListingsAPI(self._api_client)
-        self._provider_personalization_requests = service.marketplace.ProviderPersonalizationRequestsAPI(
-            self._api_client
-        )
-        self._provider_provider_analytics_dashboards = service.marketplace.ProviderProviderAnalyticsDashboardsAPI(
+        self._lakeview = pkg_dashboards.LakeviewAPI(self._api_client)
+        self._lakeview_embedded = pkg_dashboards.LakeviewEmbeddedAPI(self._api_client)
+        self._libraries = pkg_compute.LibrariesAPI(self._api_client)
+        self._metastores = pkg_catalog.MetastoresAPI(self._api_client)
+        self._model_registry = pkg_ml.ModelRegistryAPI(self._api_client)
+        self._model_versions = pkg_catalog.ModelVersionsAPI(self._api_client)
+        self._notification_destinations = pkg_settings.NotificationDestinationsAPI(self._api_client)
+        self._online_tables = pkg_catalog.OnlineTablesAPI(self._api_client)
+        self._permission_migration = pkg_iam.PermissionMigrationAPI(self._api_client)
+        self._permissions = pkg_iam.PermissionsAPI(self._api_client)
+        self._pipelines = pkg_pipelines.PipelinesAPI(self._api_client)
+        self._policy_compliance_for_clusters = pkg_compute.PolicyComplianceForClustersAPI(self._api_client)
+        self._policy_compliance_for_jobs = pkg_jobs.PolicyComplianceForJobsAPI(self._api_client)
+        self._policy_families = pkg_compute.PolicyFamiliesAPI(self._api_client)
+        self._provider_exchange_filters = pkg_marketplace.ProviderExchangeFiltersAPI(self._api_client)
+        self._provider_exchanges = pkg_marketplace.ProviderExchangesAPI(self._api_client)
+        self._provider_files = pkg_marketplace.ProviderFilesAPI(self._api_client)
+        self._provider_listings = pkg_marketplace.ProviderListingsAPI(self._api_client)
+        self._provider_personalization_requests = pkg_marketplace.ProviderPersonalizationRequestsAPI(self._api_client)
+        self._provider_provider_analytics_dashboards = pkg_marketplace.ProviderProviderAnalyticsDashboardsAPI(
             self._api_client
         )
-        self._provider_providers = service.marketplace.ProviderProvidersAPI(self._api_client)
-        self._providers = service.sharing.ProvidersAPI(self._api_client)
-        self._quality_monitors = service.catalog.QualityMonitorsAPI(self._api_client)
-        self._queries = service.sql.QueriesAPI(self._api_client)
-        self._queries_legacy = service.sql.QueriesLegacyAPI(self._api_client)
-        self._query_execution = service.dashboards.QueryExecutionAPI(self._api_client)
-        self._query_history = service.sql.QueryHistoryAPI(self._api_client)
-        self._query_visualizations = service.sql.QueryVisualizationsAPI(self._api_client)
-        self._query_visualizations_legacy = service.sql.QueryVisualizationsLegacyAPI(self._api_client)
-        self._recipient_activation = service.sharing.RecipientActivationAPI(self._api_client)
-        self._recipients = service.sharing.RecipientsAPI(self._api_client)
-        self._redash_config = service.sql.RedashConfigAPI(self._api_client)
-        self._registered_models = service.catalog.RegisteredModelsAPI(self._api_client)
-        self._repos = service.workspace.ReposAPI(self._api_client)
-        self._resource_quotas = service.catalog.ResourceQuotasAPI(self._api_client)
-        self._schemas = service.catalog.SchemasAPI(self._api_client)
-        self._secrets = service.workspace.SecretsAPI(self._api_client)
-        self._service_principals = service.iam.ServicePrincipalsAPI(self._api_client)
+        self._provider_providers = pkg_marketplace.ProviderProvidersAPI(self._api_client)
+        self._providers = pkg_sharing.ProvidersAPI(self._api_client)
+        self._quality_monitors = pkg_catalog.QualityMonitorsAPI(self._api_client)
+        self._queries = pkg_sql.QueriesAPI(self._api_client)
+        self._queries_legacy = pkg_sql.QueriesLegacyAPI(self._api_client)
+        self._query_execution = pkg_dashboards.QueryExecutionAPI(self._api_client)
+        self._query_history = pkg_sql.QueryHistoryAPI(self._api_client)
+        self._query_visualizations = pkg_sql.QueryVisualizationsAPI(self._api_client)
+        self._query_visualizations_legacy = pkg_sql.QueryVisualizationsLegacyAPI(self._api_client)
+        self._recipient_activation = pkg_sharing.RecipientActivationAPI(self._api_client)
+        self._recipient_federation_policies = pkg_sharing.RecipientFederationPoliciesAPI(self._api_client)
+        self._recipients = pkg_sharing.RecipientsAPI(self._api_client)
+        self._redash_config = pkg_sql.RedashConfigAPI(self._api_client)
+        self._registered_models = pkg_catalog.RegisteredModelsAPI(self._api_client)
+        self._repos = pkg_workspace.ReposAPI(self._api_client)
+        self._resource_quotas = pkg_catalog.ResourceQuotasAPI(self._api_client)
+        self._schemas = pkg_catalog.SchemasAPI(self._api_client)
+        self._secrets = pkg_workspace.SecretsAPI(self._api_client)
+        self._service_principals = pkg_iam.ServicePrincipalsAPI(self._api_client)
         self._serving_endpoints = serving_endpoints
         serving_endpoints_data_plane_token_source = DataPlaneTokenSource(
             self._config.host, self._config.oauth_token, self._config.disable_async_token_refresh
         )
-        self._serving_endpoints_data_plane = service.serving.ServingEndpointsDataPlaneAPI(
+        self._serving_endpoints_data_plane = pkg_serving.ServingEndpointsDataPlaneAPI(
             self._api_client, serving_endpoints, serving_endpoints_data_plane_token_source
         )
-        self._settings = service.settings.SettingsAPI(self._api_client)
-        self._shares = service.sharing.SharesAPI(self._api_client)
-        self._statement_execution = service.sql.StatementExecutionAPI(self._api_client)
-        self._storage_credentials = service.catalog.StorageCredentialsAPI(self._api_client)
-        self._system_schemas = service.catalog.SystemSchemasAPI(self._api_client)
-        self._table_constraints = service.catalog.TableConstraintsAPI(self._api_client)
-        self._tables = service.catalog.TablesAPI(self._api_client)
-        self._temporary_table_credentials = service.catalog.TemporaryTableCredentialsAPI(self._api_client)
-        self._token_management = service.settings.TokenManagementAPI(self._api_client)
-        self._tokens = service.settings.TokensAPI(self._api_client)
-        self._users = service.iam.UsersAPI(self._api_client)
-        self._vector_search_endpoints = service.vectorsearch.VectorSearchEndpointsAPI(self._api_client)
-        self._vector_search_indexes = service.vectorsearch.VectorSearchIndexesAPI(self._api_client)
-        self._volumes = service.catalog.VolumesAPI(self._api_client)
-        self._warehouses = service.sql.WarehousesAPI(self._api_client)
+        self._settings = pkg_settings.SettingsAPI(self._api_client)
+        self._shares = pkg_sharing.SharesAPI(self._api_client)
+        self._statement_execution = pkg_sql.StatementExecutionAPI(self._api_client)
+        self._storage_credentials = pkg_catalog.StorageCredentialsAPI(self._api_client)
+        self._system_schemas = pkg_catalog.SystemSchemasAPI(self._api_client)
+        self._table_constraints = pkg_catalog.TableConstraintsAPI(self._api_client)
+        self._tables = pkg_catalog.TablesAPI(self._api_client)
+        self._temporary_table_credentials = pkg_catalog.TemporaryTableCredentialsAPI(self._api_client)
+        self._token_management = pkg_settings.TokenManagementAPI(self._api_client)
+        self._tokens = pkg_settings.TokensAPI(self._api_client)
+        self._users = pkg_iam.UsersAPI(self._api_client)
+        self._vector_search_endpoints = pkg_vectorsearch.VectorSearchEndpointsAPI(self._api_client)
+        self._vector_search_indexes = pkg_vectorsearch.VectorSearchIndexesAPI(self._api_client)
+        self._volumes = pkg_catalog.VolumesAPI(self._api_client)
+        self._warehouses = pkg_sql.WarehousesAPI(self._api_client)
         self._workspace = WorkspaceExt(self._api_client)
-        self._workspace_bindings = service.catalog.WorkspaceBindingsAPI(self._api_client)
-        self._workspace_conf = service.settings.WorkspaceConfAPI(self._api_client)
-        self._forecasting = service.ml.ForecastingAPI(self._api_client)
+        self._workspace_bindings = pkg_catalog.WorkspaceBindingsAPI(self._api_client)
+        self._workspace_conf = pkg_settings.WorkspaceConfAPI(self._api_client)
+        self._forecasting = pkg_ml.ForecastingAPI(self._api_client)
 
     @property
     def config(self) -> client.Config:
@@ -330,62 +351,62 @@ class WorkspaceClient:
         return self._dbutils
 
     @property
-    def access_control(self) -> service.iam.AccessControlAPI:
+    def access_control(self) -> pkg_iam.AccessControlAPI:
         """Rule based Access Control for Databricks Resources."""
         return self._access_control
 
     @property
-    def account_access_control_proxy(self) -> service.iam.AccountAccessControlProxyAPI:
+    def account_access_control_proxy(self) -> pkg_iam.AccountAccessControlProxyAPI:
         """These APIs manage access rules on resources in an account."""
         return self._account_access_control_proxy
 
     @property
-    def alerts(self) -> service.sql.AlertsAPI:
+    def alerts(self) -> pkg_sql.AlertsAPI:
         """The alerts API can be used to perform CRUD operations on alerts."""
         return self._alerts
 
     @property
-    def alerts_legacy(self) -> service.sql.AlertsLegacyAPI:
+    def alerts_legacy(self) -> pkg_sql.AlertsLegacyAPI:
         """The alerts API can be used to perform CRUD operations on alerts."""
         return self._alerts_legacy
 
     @property
-    def alerts_v2(self) -> service.sql.AlertsV2API:
+    def alerts_v2(self) -> pkg_sql.AlertsV2API:
         """TODO: Add description."""
         return self._alerts_v2
 
     @property
-    def apps(self) -> service.apps.AppsAPI:
+    def apps(self) -> pkg_apps.AppsAPI:
         """Apps run directly on a customer’s Databricks instance, integrate with their data, use and extend Databricks services, and enable users to interact through single sign-on."""
         return self._apps
 
     @property
-    def artifact_allowlists(self) -> service.catalog.ArtifactAllowlistsAPI:
+    def artifact_allowlists(self) -> pkg_catalog.ArtifactAllowlistsAPI:
         """In Databricks Runtime 13.3 and above, you can add libraries and init scripts to the `allowlist` in UC so that users can leverage these artifacts on compute configured with shared access mode."""
         return self._artifact_allowlists
 
     @property
-    def catalogs(self) -> service.catalog.CatalogsAPI:
+    def catalogs(self) -> pkg_catalog.CatalogsAPI:
         """A catalog is the first layer of Unity Catalog’s three-level namespace."""
         return self._catalogs
 
     @property
-    def clean_room_assets(self) -> service.cleanrooms.CleanRoomAssetsAPI:
+    def clean_room_assets(self) -> pkg_cleanrooms.CleanRoomAssetsAPI:
         """Clean room assets are data and code objects — Tables, volumes, and notebooks that are shared with the clean room."""
         return self._clean_room_assets
 
     @property
-    def clean_room_task_runs(self) -> service.cleanrooms.CleanRoomTaskRunsAPI:
+    def clean_room_task_runs(self) -> pkg_cleanrooms.CleanRoomTaskRunsAPI:
         """Clean room task runs are the executions of notebooks in a clean room."""
         return self._clean_room_task_runs
 
     @property
-    def clean_rooms(self) -> service.cleanrooms.CleanRoomsAPI:
+    def clean_rooms(self) -> pkg_cleanrooms.CleanRoomsAPI:
         """A clean room uses Delta Sharing and serverless compute to provide a secure and privacy-protecting environment where multiple parties can work together on sensitive enterprise data without direct access to each other’s data."""
         return self._clean_rooms
 
     @property
-    def cluster_policies(self) -> service.compute.ClusterPoliciesAPI:
+    def cluster_policies(self) -> pkg_compute.ClusterPoliciesAPI:
         """You can use cluster policies to control users' ability to configure clusters based on a set of rules."""
         return self._cluster_policies
 
@@ -395,137 +416,142 @@ class WorkspaceClient:
         return self._clusters
 
     @property
-    def command_execution(self) -> service.compute.CommandExecutionAPI:
+    def command_execution(self) -> pkg_compute.CommandExecutionAPI:
         """This API allows execution of Python, Scala, SQL, or R commands on running Databricks Clusters."""
         return self._command_execution
 
     @property
-    def connections(self) -> service.catalog.ConnectionsAPI:
+    def connections(self) -> pkg_catalog.ConnectionsAPI:
         """Connections allow for creating a connection to an external data source."""
         return self._connections
 
     @property
-    def consumer_fulfillments(self) -> service.marketplace.ConsumerFulfillmentsAPI:
+    def consumer_fulfillments(self) -> pkg_marketplace.ConsumerFulfillmentsAPI:
         """Fulfillments are entities that allow consumers to preview installations."""
         return self._consumer_fulfillments
 
     @property
-    def consumer_installations(self) -> service.marketplace.ConsumerInstallationsAPI:
+    def consumer_installations(self) -> pkg_marketplace.ConsumerInstallationsAPI:
         """Installations are entities that allow consumers to interact with Databricks Marketplace listings."""
         return self._consumer_installations
 
     @property
-    def consumer_listings(self) -> service.marketplace.ConsumerListingsAPI:
+    def consumer_listings(self) -> pkg_marketplace.ConsumerListingsAPI:
         """Listings are the core entities in the Marketplace."""
         return self._consumer_listings
 
     @property
-    def consumer_personalization_requests(self) -> service.marketplace.ConsumerPersonalizationRequestsAPI:
+    def consumer_personalization_requests(self) -> pkg_marketplace.ConsumerPersonalizationRequestsAPI:
         """Personalization Requests allow customers to interact with the individualized Marketplace listing flow."""
         return self._consumer_personalization_requests
 
     @property
-    def consumer_providers(self) -> service.marketplace.ConsumerProvidersAPI:
+    def consumer_providers(self) -> pkg_marketplace.ConsumerProvidersAPI:
         """Providers are the entities that publish listings to the Marketplace."""
         return self._consumer_providers
 
     @property
-    def credentials(self) -> service.catalog.CredentialsAPI:
+    def credentials(self) -> pkg_catalog.CredentialsAPI:
         """A credential represents an authentication and authorization mechanism for accessing services on your cloud tenant."""
         return self._credentials
 
     @property
-    def credentials_manager(self) -> service.settings.CredentialsManagerAPI:
+    def credentials_manager(self) -> pkg_settings.CredentialsManagerAPI:
         """Credentials manager interacts with with Identity Providers to to perform token exchanges using stored credentials and refresh tokens."""
         return self._credentials_manager
 
     @property
-    def current_user(self) -> service.iam.CurrentUserAPI:
+    def current_user(self) -> pkg_iam.CurrentUserAPI:
         """This API allows retrieving information about currently authenticated user or service principal."""
         return self._current_user
 
     @property
-    def dashboard_widgets(self) -> service.sql.DashboardWidgetsAPI:
+    def dashboard_widgets(self) -> pkg_sql.DashboardWidgetsAPI:
         """This is an evolving API that facilitates the addition and removal of widgets from existing dashboards within the Databricks Workspace."""
         return self._dashboard_widgets
 
     @property
-    def dashboards(self) -> service.sql.DashboardsAPI:
+    def dashboards(self) -> pkg_sql.DashboardsAPI:
         """In general, there is little need to modify dashboards using the API."""
         return self._dashboards
 
     @property
-    def data_sources(self) -> service.sql.DataSourcesAPI:
+    def data_sources(self) -> pkg_sql.DataSourcesAPI:
         """This API is provided to assist you in making new query objects."""
         return self._data_sources
 
+    @property
+    def database_instances(self) -> pkg_catalog.DatabaseInstancesAPI:
+        """Database Instances provide access to a database via REST API or direct SQL."""
+        return self._database_instances
+
     @property
     def dbfs(self) -> DbfsExt:
         """DBFS API makes it simple to interact with various data sources without having to include a users credentials every time to read a file."""
         return self._dbfs
 
     @property
-    def dbsql_permissions(self) -> service.sql.DbsqlPermissionsAPI:
+    def dbsql_permissions(self) -> pkg_sql.DbsqlPermissionsAPI:
         """The SQL Permissions API is similar to the endpoints of the :method:permissions/set."""
         return self._dbsql_permissions
 
     @property
-    def experiments(self) -> service.ml.ExperimentsAPI:
+    def experiments(self) -> pkg_ml.ExperimentsAPI:
         """Experiments are the primary unit of organization in MLflow; all MLflow runs belong to an experiment."""
         return self._experiments
 
     @property
-    def external_locations(self) -> service.catalog.ExternalLocationsAPI:
+    def external_locations(self) -> pkg_catalog.ExternalLocationsAPI:
         """An external location is an object that combines a cloud storage path with a storage credential that authorizes access to the cloud storage path."""
         return self._external_locations
 
     @property
-    def files(self) -> service.files.FilesAPI:
+    def files(self) -> pkg_files.FilesAPI:
         """The Files API is a standard HTTP API that allows you to read, write, list, and delete files and directories by referring to their URI."""
         return self._files
 
     @property
-    def functions(self) -> service.catalog.FunctionsAPI:
+    def functions(self) -> pkg_catalog.FunctionsAPI:
         """Functions implement User-Defined Functions (UDFs) in Unity Catalog."""
         return self._functions
 
     @property
-    def genie(self) -> service.dashboards.GenieAPI:
+    def genie(self) -> pkg_dashboards.GenieAPI:
         """Genie provides a no-code experience for business users, powered by AI/BI."""
         return self._genie
 
     @property
-    def git_credentials(self) -> service.workspace.GitCredentialsAPI:
+    def git_credentials(self) -> pkg_workspace.GitCredentialsAPI:
         """Registers personal access token for Databricks to do operations on behalf of the user."""
         return self._git_credentials
 
     @property
-    def global_init_scripts(self) -> service.compute.GlobalInitScriptsAPI:
+    def global_init_scripts(self) -> pkg_compute.GlobalInitScriptsAPI:
         """The Global Init Scripts API enables Workspace administrators to configure global initialization scripts for their workspace."""
         return self._global_init_scripts
 
     @property
-    def grants(self) -> service.catalog.GrantsAPI:
+    def grants(self) -> pkg_catalog.GrantsAPI:
         """In Unity Catalog, data is secure by default."""
         return self._grants
 
     @property
-    def groups(self) -> service.iam.GroupsAPI:
+    def groups(self) -> pkg_iam.GroupsAPI:
         """Groups simplify identity management, making it easier to assign access to Databricks workspace, data, and other securable objects."""
         return self._groups
 
     @property
-    def instance_pools(self) -> service.compute.InstancePoolsAPI:
+    def instance_pools(self) -> pkg_compute.InstancePoolsAPI:
         """Instance Pools API are used to create, edit, delete and list instance pools by using ready-to-use cloud instances which reduces a cluster start and auto-scaling times."""
         return self._instance_pools
 
     @property
-    def instance_profiles(self) -> service.compute.InstanceProfilesAPI:
+    def instance_profiles(self) -> pkg_compute.InstanceProfilesAPI:
         """The Instance Profiles API allows admins to add, list, and remove instance profiles that users can launch clusters with."""
         return self._instance_profiles
 
     @property
-    def ip_access_lists(self) -> service.settings.IpAccessListsAPI:
+    def ip_access_lists(self) -> pkg_settings.IpAccessListsAPI:
         """IP Access List enables admins to configure IP access lists."""
         return self._ip_access_lists
 
@@ -535,192 +561,197 @@ class WorkspaceClient:
         return self._jobs
 
     @property
-    def lakeview(self) -> service.dashboards.LakeviewAPI:
+    def lakeview(self) -> pkg_dashboards.LakeviewAPI:
         """These APIs provide specific management operations for Lakeview dashboards."""
         return self._lakeview
 
     @property
-    def lakeview_embedded(self) -> service.dashboards.LakeviewEmbeddedAPI:
+    def lakeview_embedded(self) -> pkg_dashboards.LakeviewEmbeddedAPI:
         """Token-based Lakeview APIs for embedding dashboards in external applications."""
         return self._lakeview_embedded
 
     @property
-    def libraries(self) -> service.compute.LibrariesAPI:
+    def libraries(self) -> pkg_compute.LibrariesAPI:
         """The Libraries API allows you to install and uninstall libraries and get the status of libraries on a cluster."""
         return self._libraries
 
     @property
-    def metastores(self) -> service.catalog.MetastoresAPI:
+    def metastores(self) -> pkg_catalog.MetastoresAPI:
         """A metastore is the top-level container of objects in Unity Catalog."""
         return self._metastores
 
     @property
-    def model_registry(self) -> service.ml.ModelRegistryAPI:
+    def model_registry(self) -> pkg_ml.ModelRegistryAPI:
         """Note: This API reference documents APIs for the Workspace Model Registry."""
         return self._model_registry
 
     @property
-    def model_versions(self) -> service.catalog.ModelVersionsAPI:
+    def model_versions(self) -> pkg_catalog.ModelVersionsAPI:
         """Databricks provides a hosted version of MLflow Model Registry in Unity Catalog."""
         return self._model_versions
 
     @property
-    def notification_destinations(self) -> service.settings.NotificationDestinationsAPI:
+    def notification_destinations(self) -> pkg_settings.NotificationDestinationsAPI:
         """The notification destinations API lets you programmatically manage a workspace's notification destinations."""
         return self._notification_destinations
 
     @property
-    def online_tables(self) -> service.catalog.OnlineTablesAPI:
+    def online_tables(self) -> pkg_catalog.OnlineTablesAPI:
         """Online tables provide lower latency and higher QPS access to data from Delta tables."""
         return self._online_tables
 
     @property
-    def permission_migration(self) -> service.iam.PermissionMigrationAPI:
+    def permission_migration(self) -> pkg_iam.PermissionMigrationAPI:
         """APIs for migrating acl permissions, used only by the ucx tool: https://github.com/databrickslabs/ucx."""
         return self._permission_migration
 
     @property
-    def permissions(self) -> service.iam.PermissionsAPI:
+    def permissions(self) -> pkg_iam.PermissionsAPI:
         """Permissions API are used to create read, write, edit, update and manage access for various users on different objects and endpoints."""
         return self._permissions
 
     @property
-    def pipelines(self) -> service.pipelines.PipelinesAPI:
+    def pipelines(self) -> pkg_pipelines.PipelinesAPI:
         """The Delta Live Tables API allows you to create, edit, delete, start, and view details about pipelines."""
         return self._pipelines
 
     @property
-    def policy_compliance_for_clusters(self) -> service.compute.PolicyComplianceForClustersAPI:
+    def policy_compliance_for_clusters(self) -> pkg_compute.PolicyComplianceForClustersAPI:
         """The policy compliance APIs allow you to view and manage the policy compliance status of clusters in your workspace."""
         return self._policy_compliance_for_clusters
 
     @property
-    def policy_compliance_for_jobs(self) -> service.jobs.PolicyComplianceForJobsAPI:
+    def policy_compliance_for_jobs(self) -> pkg_jobs.PolicyComplianceForJobsAPI:
         """The compliance APIs allow you to view and manage the policy compliance status of jobs in your workspace."""
         return self._policy_compliance_for_jobs
 
     @property
-    def policy_families(self) -> service.compute.PolicyFamiliesAPI:
+    def policy_families(self) -> pkg_compute.PolicyFamiliesAPI:
         """View available policy families."""
         return self._policy_families
 
     @property
-    def provider_exchange_filters(self) -> service.marketplace.ProviderExchangeFiltersAPI:
+    def provider_exchange_filters(self) -> pkg_marketplace.ProviderExchangeFiltersAPI:
         """Marketplace exchanges filters curate which groups can access an exchange."""
         return self._provider_exchange_filters
 
     @property
-    def provider_exchanges(self) -> service.marketplace.ProviderExchangesAPI:
+    def provider_exchanges(self) -> pkg_marketplace.ProviderExchangesAPI:
         """Marketplace exchanges allow providers to share their listings with a curated set of customers."""
         return self._provider_exchanges
 
     @property
-    def provider_files(self) -> service.marketplace.ProviderFilesAPI:
+    def provider_files(self) -> pkg_marketplace.ProviderFilesAPI:
         """Marketplace offers a set of file APIs for various purposes such as preview notebooks and provider icons."""
         return self._provider_files
 
     @property
-    def provider_listings(self) -> service.marketplace.ProviderListingsAPI:
+    def provider_listings(self) -> pkg_marketplace.ProviderListingsAPI:
         """Listings are the core entities in the Marketplace."""
         return self._provider_listings
 
     @property
-    def provider_personalization_requests(self) -> service.marketplace.ProviderPersonalizationRequestsAPI:
+    def provider_personalization_requests(self) -> pkg_marketplace.ProviderPersonalizationRequestsAPI:
         """Personalization requests are an alternate to instantly available listings."""
         return self._provider_personalization_requests
 
     @property
-    def provider_provider_analytics_dashboards(self) -> service.marketplace.ProviderProviderAnalyticsDashboardsAPI:
+    def provider_provider_analytics_dashboards(self) -> pkg_marketplace.ProviderProviderAnalyticsDashboardsAPI:
         """Manage templated analytics solution for providers."""
         return self._provider_provider_analytics_dashboards
 
     @property
-    def provider_providers(self) -> service.marketplace.ProviderProvidersAPI:
+    def provider_providers(self) -> pkg_marketplace.ProviderProvidersAPI:
         """Providers are entities that manage assets in Marketplace."""
         return self._provider_providers
 
     @property
-    def providers(self) -> service.sharing.ProvidersAPI:
+    def providers(self) -> pkg_sharing.ProvidersAPI:
         """A data provider is an object representing the organization in the real world who shares the data."""
         return self._providers
 
     @property
-    def quality_monitors(self) -> service.catalog.QualityMonitorsAPI:
+    def quality_monitors(self) -> pkg_catalog.QualityMonitorsAPI:
         """A monitor computes and monitors data or model quality metrics for a table over time."""
         return self._quality_monitors
 
     @property
-    def queries(self) -> service.sql.QueriesAPI:
+    def queries(self) -> pkg_sql.QueriesAPI:
         """The queries API can be used to perform CRUD operations on queries."""
         return self._queries
 
     @property
-    def queries_legacy(self) -> service.sql.QueriesLegacyAPI:
+    def queries_legacy(self) -> pkg_sql.QueriesLegacyAPI:
         """These endpoints are used for CRUD operations on query definitions."""
         return self._queries_legacy
 
     @property
-    def query_execution(self) -> service.dashboards.QueryExecutionAPI:
+    def query_execution(self) -> pkg_dashboards.QueryExecutionAPI:
         """Query execution APIs for AI / BI Dashboards."""
         return self._query_execution
 
     @property
-    def query_history(self) -> service.sql.QueryHistoryAPI:
+    def query_history(self) -> pkg_sql.QueryHistoryAPI:
         """A service responsible for storing and retrieving the list of queries run against SQL endpoints and serverless compute."""
         return self._query_history
 
     @property
-    def query_visualizations(self) -> service.sql.QueryVisualizationsAPI:
+    def query_visualizations(self) -> pkg_sql.QueryVisualizationsAPI:
         """This is an evolving API that facilitates the addition and removal of visualizations from existing queries in the Databricks Workspace."""
         return self._query_visualizations
 
     @property
-    def query_visualizations_legacy(self) -> service.sql.QueryVisualizationsLegacyAPI:
+    def query_visualizations_legacy(self) -> pkg_sql.QueryVisualizationsLegacyAPI:
         """This is an evolving API that facilitates the addition and removal of vizualisations from existing queries within the Databricks Workspace."""
         return self._query_visualizations_legacy
 
     @property
-    def recipient_activation(self) -> service.sharing.RecipientActivationAPI:
+    def recipient_activation(self) -> pkg_sharing.RecipientActivationAPI:
         """The Recipient Activation API is only applicable in the open sharing model where the recipient object has the authentication type of `TOKEN`."""
         return self._recipient_activation
 
     @property
-    def recipients(self) -> service.sharing.RecipientsAPI:
+    def recipient_federation_policies(self) -> pkg_sharing.RecipientFederationPoliciesAPI:
+        """The Recipient Federation Policies APIs are only applicable in the open sharing model where the recipient object has the authentication type of `OIDC_RECIPIENT`, enabling data sharing from Databricks to non-Databricks recipients."""
+        return self._recipient_federation_policies
+
+    @property
+    def recipients(self) -> pkg_sharing.RecipientsAPI:
         """A recipient is an object you create using :method:recipients/create to represent an organization which you want to allow access shares."""
         return self._recipients
 
     @property
-    def redash_config(self) -> service.sql.RedashConfigAPI:
+    def redash_config(self) -> pkg_sql.RedashConfigAPI:
         """Redash V2 service for workspace configurations (internal)."""
         return self._redash_config
 
     @property
-    def registered_models(self) -> service.catalog.RegisteredModelsAPI:
+    def registered_models(self) -> pkg_catalog.RegisteredModelsAPI:
         """Databricks provides a hosted version of MLflow Model Registry in Unity Catalog."""
         return self._registered_models
 
     @property
-    def repos(self) -> service.workspace.ReposAPI:
+    def repos(self) -> pkg_workspace.ReposAPI:
         """The Repos API allows users to manage their git repos."""
         return self._repos
 
     @property
-    def resource_quotas(self) -> service.catalog.ResourceQuotasAPI:
+    def resource_quotas(self) -> pkg_catalog.ResourceQuotasAPI:
         """Unity Catalog enforces resource quotas on all securable objects, which limits the number of resources that can be created."""
         return self._resource_quotas
 
     @property
-    def schemas(self) -> service.catalog.SchemasAPI:
+    def schemas(self) -> pkg_catalog.SchemasAPI:
         """A schema (also called a database) is the second layer of Unity Catalog’s three-level namespace."""
         return self._schemas
 
     @property
-    def secrets(self) -> service.workspace.SecretsAPI:
+    def secrets(self) -> pkg_workspace.SecretsAPI:
         """The Secrets API allows you to manage secrets, secret scopes, and access permissions."""
         return self._secrets
 
     @property
-    def service_principals(self) -> service.iam.ServicePrincipalsAPI:
+    def service_principals(self) -> pkg_iam.ServicePrincipalsAPI:
         """Identities for use with jobs, automated tools, and systems such as scripts, apps, and CI/CD platforms."""
         return self._service_principals
 
@@ -730,82 +761,82 @@ class WorkspaceClient:
         return self._serving_endpoints
 
     @property
-    def serving_endpoints_data_plane(self) -> service.serving.ServingEndpointsDataPlaneAPI:
+    def serving_endpoints_data_plane(self) -> pkg_serving.ServingEndpointsDataPlaneAPI:
         """Serving endpoints DataPlane provides a set of operations to interact with data plane endpoints for Serving endpoints service."""
         return self._serving_endpoints_data_plane
 
     @property
-    def settings(self) -> service.settings.SettingsAPI:
+    def settings(self) -> pkg_settings.SettingsAPI:
         """Workspace Settings API allows users to manage settings at the workspace level."""
         return self._settings
 
     @property
-    def shares(self) -> service.sharing.SharesAPI:
+    def shares(self) -> pkg_sharing.SharesAPI:
         """A share is a container instantiated with :method:shares/create."""
         return self._shares
 
     @property
-    def statement_execution(self) -> service.sql.StatementExecutionAPI:
+    def statement_execution(self) -> pkg_sql.StatementExecutionAPI:
         """The Databricks SQL Statement Execution API can be used to execute SQL statements on a SQL warehouse and fetch the result."""
         return self._statement_execution
 
     @property
-    def storage_credentials(self) -> service.catalog.StorageCredentialsAPI:
+    def storage_credentials(self) -> pkg_catalog.StorageCredentialsAPI:
         """A storage credential represents an authentication and authorization mechanism for accessing data stored on your cloud tenant."""
         return self._storage_credentials
 
     @property
-    def system_schemas(self) -> service.catalog.SystemSchemasAPI:
+    def system_schemas(self) -> pkg_catalog.SystemSchemasAPI:
         """A system schema is a schema that lives within the system catalog."""
         return self._system_schemas
 
     @property
-    def table_constraints(self) -> service.catalog.TableConstraintsAPI:
+    def table_constraints(self) -> pkg_catalog.TableConstraintsAPI:
         """Primary key and foreign key constraints encode relationships between fields in tables."""
         return self._table_constraints
 
     @property
-    def tables(self) -> service.catalog.TablesAPI:
+    def tables(self) -> pkg_catalog.TablesAPI:
         """A table resides in the third layer of Unity Catalog’s three-level namespace."""
         return self._tables
 
     @property
-    def temporary_table_credentials(self) -> service.catalog.TemporaryTableCredentialsAPI:
+    def temporary_table_credentials(self) -> pkg_catalog.TemporaryTableCredentialsAPI:
         """Temporary Table Credentials refer to short-lived, downscoped credentials used to access cloud storage locationswhere table data is stored in Databricks."""
         return self._temporary_table_credentials
 
     @property
-    def token_management(self) -> service.settings.TokenManagementAPI:
+    def token_management(self) -> pkg_settings.TokenManagementAPI:
         """Enables administrators to get all tokens and delete tokens for other users."""
         return self._token_management
 
     @property
-    def tokens(self) -> service.settings.TokensAPI:
+    def tokens(self) -> pkg_settings.TokensAPI:
         """The Token API allows you to create, list, and revoke tokens that can be used to authenticate and access Databricks REST APIs."""
         return self._tokens
 
     @property
-    def users(self) -> service.iam.UsersAPI:
+    def users(self) -> pkg_iam.UsersAPI:
         """User identities recognized by Databricks and represented by email addresses."""
         return self._users
 
     @property
-    def vector_search_endpoints(self) -> service.vectorsearch.VectorSearchEndpointsAPI:
+    def vector_search_endpoints(self) -> pkg_vectorsearch.VectorSearchEndpointsAPI:
         """**Endpoint**: Represents the compute resources to host vector search indexes."""
         return self._vector_search_endpoints
 
     @property
-    def vector_search_indexes(self) -> service.vectorsearch.VectorSearchIndexesAPI:
+    def vector_search_indexes(self) -> pkg_vectorsearch.VectorSearchIndexesAPI:
         """**Index**: An efficient representation of your embedding vectors that supports real-time and efficient approximate nearest neighbor (ANN) search queries."""
         return self._vector_search_indexes
 
     @property
-    def volumes(self) -> service.catalog.VolumesAPI:
+    def volumes(self) -> pkg_catalog.VolumesAPI:
         """Volumes are a Unity Catalog (UC) capability for accessing, storing, governing, organizing and processing files."""
         return self._volumes
 
     @property
-    def warehouses(self) -> service.sql.WarehousesAPI:
+    def warehouses(self) -> pkg_sql.WarehousesAPI:
         """A SQL warehouse is a compute resource that lets you run SQL commands on data objects within Databricks SQL."""
         return self._warehouses
 
@@ -815,17 +846,17 @@ class WorkspaceClient:
         return self._workspace
 
     @property
-    def workspace_bindings(self) -> service.catalog.WorkspaceBindingsAPI:
+    def workspace_bindings(self) -> pkg_catalog.WorkspaceBindingsAPI:
         """A securable in Databricks can be configured as __OPEN__ or __ISOLATED__."""
         return self._workspace_bindings
 
     @property
-    def workspace_conf(self) -> service.settings.WorkspaceConfAPI:
+    def workspace_conf(self) -> pkg_settings.WorkspaceConfAPI:
         """This API allows updating known workspace settings for advanced users."""
         return self._workspace_conf
 
     @property
-    def forecasting(self) -> service.ml.ForecastingAPI:
+    def forecasting(self) -> pkg_ml.ForecastingAPI:
         """The Forecasting API allows you to create and get serverless forecasting experiments."""
         return self._forecasting
 
@@ -903,35 +934,37 @@ class AccountClient:
             )
         self._config = config.copy()
         self._api_client = client.ApiClient(self._config)
-        self._access_control = service.iam.AccountAccessControlAPI(self._api_client)
-        self._billable_usage = service.billing.BillableUsageAPI(self._api_client)
-        self._budget_policy = service.billing.BudgetPolicyAPI(self._api_client)
-        self._credentials = service.provisioning.CredentialsAPI(self._api_client)
-        self._custom_app_integration = service.oauth2.CustomAppIntegrationAPI(self._api_client)
-        self._encryption_keys = service.provisioning.EncryptionKeysAPI(self._api_client)
-        self._federation_policy = service.oauth2.AccountFederationPolicyAPI(self._api_client)
-        self._groups = service.iam.AccountGroupsAPI(self._api_client)
-        self._ip_access_lists = service.settings.AccountIpAccessListsAPI(self._api_client)
-        self._log_delivery = service.billing.LogDeliveryAPI(self._api_client)
-        self._metastore_assignments = service.catalog.AccountMetastoreAssignmentsAPI(self._api_client)
-        self._metastores = service.catalog.AccountMetastoresAPI(self._api_client)
-        self._network_connectivity = service.settings.NetworkConnectivityAPI(self._api_client)
-        self._networks = service.provisioning.NetworksAPI(self._api_client)
-        self._o_auth_published_apps = service.oauth2.OAuthPublishedAppsAPI(self._api_client)
-        self._private_access = service.provisioning.PrivateAccessAPI(self._api_client)
-        self._published_app_integration = service.oauth2.PublishedAppIntegrationAPI(self._api_client)
-        self._service_principal_federation_policy = service.oauth2.ServicePrincipalFederationPolicyAPI(self._api_client)
-        self._service_principal_secrets = service.oauth2.ServicePrincipalSecretsAPI(self._api_client)
-        self._service_principals = service.iam.AccountServicePrincipalsAPI(self._api_client)
-        self._settings = service.settings.AccountSettingsAPI(self._api_client)
-        self._storage = service.provisioning.StorageAPI(self._api_client)
-        self._storage_credentials = service.catalog.AccountStorageCredentialsAPI(self._api_client)
-        self._usage_dashboards = service.billing.UsageDashboardsAPI(self._api_client)
-        self._users = service.iam.AccountUsersAPI(self._api_client)
-        self._vpc_endpoints = service.provisioning.VpcEndpointsAPI(self._api_client)
-        self._workspace_assignment = service.iam.WorkspaceAssignmentAPI(self._api_client)
-        self._workspaces = service.provisioning.WorkspacesAPI(self._api_client)
-        self._budgets = service.billing.BudgetsAPI(self._api_client)
+        self._access_control = pkg_iam.AccountAccessControlAPI(self._api_client)
+        self._billable_usage = pkg_billing.BillableUsageAPI(self._api_client)
+        self._budget_policy = pkg_billing.BudgetPolicyAPI(self._api_client)
+        self._credentials = pkg_provisioning.CredentialsAPI(self._api_client)
+        self._custom_app_integration = pkg_oauth2.CustomAppIntegrationAPI(self._api_client)
+        self._encryption_keys = pkg_provisioning.EncryptionKeysAPI(self._api_client)
+        self._federation_policy = pkg_oauth2.AccountFederationPolicyAPI(self._api_client)
+        self._groups = pkg_iam.AccountGroupsAPI(self._api_client)
+        self._ip_access_lists = pkg_settings.AccountIpAccessListsAPI(self._api_client)
+        self._log_delivery = pkg_billing.LogDeliveryAPI(self._api_client)
+        self._metastore_assignments = pkg_catalog.AccountMetastoreAssignmentsAPI(self._api_client)
+        self._metastores = pkg_catalog.AccountMetastoresAPI(self._api_client)
+        self._network_connectivity = pkg_settings.NetworkConnectivityAPI(self._api_client)
+        self._network_policies = pkg_settings.NetworkPoliciesAPI(self._api_client)
+        self._networks = pkg_provisioning.NetworksAPI(self._api_client)
+        self._o_auth_published_apps = pkg_oauth2.OAuthPublishedAppsAPI(self._api_client)
+        self._private_access = pkg_provisioning.PrivateAccessAPI(self._api_client)
+        self._published_app_integration = pkg_oauth2.PublishedAppIntegrationAPI(self._api_client)
+        self._service_principal_federation_policy = pkg_oauth2.ServicePrincipalFederationPolicyAPI(self._api_client)
+        self._service_principal_secrets = pkg_oauth2.ServicePrincipalSecretsAPI(self._api_client)
+        self._service_principals = pkg_iam.AccountServicePrincipalsAPI(self._api_client)
+        self._settings = pkg_settings.AccountSettingsAPI(self._api_client)
+        self._storage = pkg_provisioning.StorageAPI(self._api_client)
+        self._storage_credentials = pkg_catalog.AccountStorageCredentialsAPI(self._api_client)
+        self._usage_dashboards = pkg_billing.UsageDashboardsAPI(self._api_client)
+        self._users = pkg_iam.AccountUsersAPI(self._api_client)
+        self._vpc_endpoints = pkg_provisioning.VpcEndpointsAPI(self._api_client)
+        self._workspace_assignment = pkg_iam.WorkspaceAssignmentAPI(self._api_client)
+        self._workspace_network_configuration = pkg_settings.WorkspaceNetworkConfigurationAPI(self._api_client)
+        self._workspaces = pkg_provisioning.WorkspacesAPI(self._api_client)
+        self._budgets = pkg_billing.BudgetsAPI(self._api_client)
 
     @property
     def config(self) -> client.Config:
@@ -942,147 +975,157 @@ class AccountClient:
         return self._api_client
 
     @property
-    def access_control(self) -> service.iam.AccountAccessControlAPI:
+    def access_control(self) -> pkg_iam.AccountAccessControlAPI:
         """These APIs manage access rules on resources in an account."""
         return self._access_control
 
     @property
-    def billable_usage(self) -> service.billing.BillableUsageAPI:
+    def billable_usage(self) -> pkg_billing.BillableUsageAPI:
         """This API allows you to download billable usage logs for the specified account and date range."""
         return self._billable_usage
 
     @property
-    def budget_policy(self) -> service.billing.BudgetPolicyAPI:
+    def budget_policy(self) -> pkg_billing.BudgetPolicyAPI:
         """A service serves REST API about Budget policies."""
         return self._budget_policy
 
     @property
-    def credentials(self) -> service.provisioning.CredentialsAPI:
+    def credentials(self) -> pkg_provisioning.CredentialsAPI:
         """These APIs manage credential configurations for this workspace."""
         return self._credentials
 
     @property
-    def custom_app_integration(self) -> service.oauth2.CustomAppIntegrationAPI:
+    def custom_app_integration(self) -> pkg_oauth2.CustomAppIntegrationAPI:
         """These APIs enable administrators to manage custom OAuth app integrations, which is required for adding/using Custom OAuth App Integration like Tableau Cloud for Databricks in AWS cloud."""
         return self._custom_app_integration
 
     @property
-    def encryption_keys(self) -> service.provisioning.EncryptionKeysAPI:
+    def encryption_keys(self) -> pkg_provisioning.EncryptionKeysAPI:
         """These APIs manage encryption key configurations for this workspace (optional)."""
         return self._encryption_keys
 
     @property
-    def federation_policy(self) -> service.oauth2.AccountFederationPolicyAPI:
+    def federation_policy(self) -> pkg_oauth2.AccountFederationPolicyAPI:
         """These APIs manage account federation policies."""
         return self._federation_policy
 
     @property
-    def groups(self) -> service.iam.AccountGroupsAPI:
+    def groups(self) -> pkg_iam.AccountGroupsAPI:
         """Groups simplify identity management, making it easier to assign access to Databricks account, data, and other securable objects."""
         return self._groups
 
     @property
-    def ip_access_lists(self) -> service.settings.AccountIpAccessListsAPI:
+    def ip_access_lists(self) -> pkg_settings.AccountIpAccessListsAPI:
         """The Accounts IP Access List API enables account admins to configure IP access lists for access to the account console."""
         return self._ip_access_lists
 
     @property
-    def log_delivery(self) -> service.billing.LogDeliveryAPI:
+    def log_delivery(self) -> pkg_billing.LogDeliveryAPI:
         """These APIs manage log delivery configurations for this account."""
         return self._log_delivery
 
     @property
-    def metastore_assignments(self) -> service.catalog.AccountMetastoreAssignmentsAPI:
+    def metastore_assignments(self) -> pkg_catalog.AccountMetastoreAssignmentsAPI:
         """These APIs manage metastore assignments to a workspace."""
         return self._metastore_assignments
 
     @property
-    def metastores(self) -> service.catalog.AccountMetastoresAPI:
+    def metastores(self) -> pkg_catalog.AccountMetastoresAPI:
         """These APIs manage Unity Catalog metastores for an account."""
         return self._metastores
 
     @property
-    def network_connectivity(self) -> service.settings.NetworkConnectivityAPI:
+    def network_connectivity(self) -> pkg_settings.NetworkConnectivityAPI:
         """These APIs provide configurations for the network connectivity of your workspaces for serverless compute resources."""
         return self._network_connectivity
 
     @property
-    def networks(self) -> service.provisioning.NetworksAPI:
+    def network_policies(self) -> pkg_settings.NetworkPoliciesAPI:
+        """These APIs manage network policies for this account."""
+        return self._network_policies
+
+    @property
+    def networks(self) -> pkg_provisioning.NetworksAPI:
         """These APIs manage network configurations for customer-managed VPCs (optional)."""
         return self._networks
 
     @property
-    def o_auth_published_apps(self) -> service.oauth2.OAuthPublishedAppsAPI:
+    def o_auth_published_apps(self) -> pkg_oauth2.OAuthPublishedAppsAPI:
         """These APIs enable administrators to view all the available published OAuth applications in Databricks."""
         return self._o_auth_published_apps
 
     @property
-    def private_access(self) -> service.provisioning.PrivateAccessAPI:
+    def private_access(self) -> pkg_provisioning.PrivateAccessAPI:
         """These APIs manage private access settings for this account."""
         return self._private_access
 
     @property
-    def published_app_integration(self) -> service.oauth2.PublishedAppIntegrationAPI:
+    def published_app_integration(self) -> pkg_oauth2.PublishedAppIntegrationAPI:
         """These APIs enable administrators to manage published OAuth app integrations, which is required for adding/using Published OAuth App Integration like Tableau Desktop for Databricks in AWS cloud."""
         return self._published_app_integration
 
     @property
-    def service_principal_federation_policy(self) -> service.oauth2.ServicePrincipalFederationPolicyAPI:
+    def service_principal_federation_policy(self) -> pkg_oauth2.ServicePrincipalFederationPolicyAPI:
         """These APIs manage service principal federation policies."""
         return self._service_principal_federation_policy
 
     @property
-    def service_principal_secrets(self) -> service.oauth2.ServicePrincipalSecretsAPI:
+    def service_principal_secrets(self) -> pkg_oauth2.ServicePrincipalSecretsAPI:
         """These APIs enable administrators to manage service principal secrets."""
         return self._service_principal_secrets
 
     @property
-    def service_principals(self) -> service.iam.AccountServicePrincipalsAPI:
+    def service_principals(self) -> pkg_iam.AccountServicePrincipalsAPI:
         """Identities for use with jobs, automated tools, and systems such as scripts, apps, and CI/CD platforms."""
         return self._service_principals
 
     @property
-    def settings(self) -> service.settings.AccountSettingsAPI:
+    def settings(self) -> pkg_settings.AccountSettingsAPI:
         """Accounts Settings API allows users to manage settings at the account level."""
         return self._settings
 
     @property
-    def storage(self) -> service.provisioning.StorageAPI:
+    def storage(self) -> pkg_provisioning.StorageAPI:
         """These APIs manage storage configurations for this workspace."""
         return self._storage
 
     @property
-    def storage_credentials(self) -> service.catalog.AccountStorageCredentialsAPI:
+    def storage_credentials(self) -> pkg_catalog.AccountStorageCredentialsAPI:
         """These APIs manage storage credentials for a particular metastore."""
         return self._storage_credentials
 
     @property
-    def usage_dashboards(self) -> service.billing.UsageDashboardsAPI:
+    def usage_dashboards(self) -> pkg_billing.UsageDashboardsAPI:
         """These APIs manage usage dashboards for this account."""
         return self._usage_dashboards
 
     @property
-    def users(self) -> service.iam.AccountUsersAPI:
+    def users(self) -> pkg_iam.AccountUsersAPI:
         """User identities recognized by Databricks and represented by email addresses."""
         return self._users
 
     @property
-    def vpc_endpoints(self) -> service.provisioning.VpcEndpointsAPI:
+    def vpc_endpoints(self) -> pkg_provisioning.VpcEndpointsAPI:
         """These APIs manage VPC endpoint configurations for this account."""
         return self._vpc_endpoints
 
     @property
-    def workspace_assignment(self) -> service.iam.WorkspaceAssignmentAPI:
+    def workspace_assignment(self) -> pkg_iam.WorkspaceAssignmentAPI:
         """The Workspace Permission Assignment API allows you to manage workspace permissions for principals in your account."""
         return self._workspace_assignment
 
     @property
-    def workspaces(self) -> service.provisioning.WorkspacesAPI:
+    def workspace_network_configuration(self) -> pkg_settings.WorkspaceNetworkConfigurationAPI:
+        """These APIs allow configuration of network settings for Databricks workspaces."""
+        return self._workspace_network_configuration
+
+    @property
+    def workspaces(self) -> pkg_provisioning.WorkspacesAPI:
         """These APIs manage workspaces for this account."""
         return self._workspaces
 
     @property
-    def budgets(self) -> service.billing.BudgetsAPI:
+    def budgets(self) -> pkg_billing.BudgetsAPI:
         """These APIs manage budget configurations for this account."""
         return self._budgets