databricks-sdk 0.42.0__py3-none-any.whl → 0.43.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.mixins.compute import ClustersExt
@@ -43,7 +42,9 @@ from databricks.sdk.service.compute import (ClusterPoliciesAPI, ClustersAPI,
                                             InstanceProfilesAPI, LibrariesAPI,
                                             PolicyComplianceForClustersAPI,
                                             PolicyFamiliesAPI)
-from databricks.sdk.service.dashboards import GenieAPI, LakeviewAPI
+from databricks.sdk.service.dashboards import (GenieAPI, LakeviewAPI,
+                                               LakeviewEmbeddedAPI,
+                                               QueryExecutionAPI)
 from databricks.sdk.service.files import DbfsAPI, FilesAPI
 from databricks.sdk.service.iam import (AccessControlAPI,
                                         AccountAccessControlAPI,
@@ -97,7 +98,8 @@ from databricks.sdk.service.sql import (AlertsAPI, AlertsLegacyAPI,
                                         QueryHistoryAPI,
                                         QueryVisualizationsAPI,
                                         QueryVisualizationsLegacyAPI,
-                                        StatementExecutionAPI, WarehousesAPI)
+                                        RedashConfigAPI, StatementExecutionAPI,
+                                        WarehousesAPI)
 from databricks.sdk.service.vectorsearch import (VectorSearchEndpointsAPI,
                                                  VectorSearchIndexesAPI)
 from databricks.sdk.service.workspace import (GitCredentialsAPI, ReposAPI,
@@ -191,106 +193,105 @@ 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._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 = AccessControlAPI(self._api_client)
+        self._account_access_control_proxy = AccountAccessControlProxyAPI(self._api_client)
+        self._alerts = AlertsAPI(self._api_client)
+        self._alerts_legacy = AlertsLegacyAPI(self._api_client)
+        self._apps = AppsAPI(self._api_client)
+        self._artifact_allowlists = ArtifactAllowlistsAPI(self._api_client)
+        self._catalogs = CatalogsAPI(self._api_client)
+        self._clean_room_assets = CleanRoomAssetsAPI(self._api_client)
+        self._clean_room_task_runs = CleanRoomTaskRunsAPI(self._api_client)
+        self._clean_rooms = CleanRoomsAPI(self._api_client)
+        self._cluster_policies = 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 = CommandExecutionAPI(self._api_client)
+        self._connections = ConnectionsAPI(self._api_client)
+        self._consumer_fulfillments = ConsumerFulfillmentsAPI(self._api_client)
+        self._consumer_installations = ConsumerInstallationsAPI(self._api_client)
+        self._consumer_listings = ConsumerListingsAPI(self._api_client)
+        self._consumer_personalization_requests = ConsumerPersonalizationRequestsAPI(self._api_client)
+        self._consumer_providers = ConsumerProvidersAPI(self._api_client)
+        self._credentials = CredentialsAPI(self._api_client)
+        self._credentials_manager = CredentialsManagerAPI(self._api_client)
+        self._current_user = CurrentUserAPI(self._api_client)
+        self._dashboard_widgets = DashboardWidgetsAPI(self._api_client)
+        self._dashboards = DashboardsAPI(self._api_client)
+        self._data_sources = DataSourcesAPI(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 = DbsqlPermissionsAPI(self._api_client)
+        self._experiments = ExperimentsAPI(self._api_client)
+        self._external_locations = 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 = FunctionsAPI(self._api_client)
+        self._genie = GenieAPI(self._api_client)
+        self._git_credentials = GitCredentialsAPI(self._api_client)
+        self._global_init_scripts = GlobalInitScriptsAPI(self._api_client)
+        self._grants = GrantsAPI(self._api_client)
+        self._groups = GroupsAPI(self._api_client)
+        self._instance_pools = InstancePoolsAPI(self._api_client)
+        self._instance_profiles = InstanceProfilesAPI(self._api_client)
+        self._ip_access_lists = IpAccessListsAPI(self._api_client)
         self._jobs = JobsExt(self._api_client)
-        self._lakeview = service.dashboards.LakeviewAPI(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 = LakeviewAPI(self._api_client)
+        self._lakeview_embedded = LakeviewEmbeddedAPI(self._api_client)
+        self._libraries = LibrariesAPI(self._api_client)
+        self._metastores = MetastoresAPI(self._api_client)
+        self._model_registry = ModelRegistryAPI(self._api_client)
+        self._model_versions = ModelVersionsAPI(self._api_client)
+        self._notification_destinations = NotificationDestinationsAPI(self._api_client)
+        self._online_tables = OnlineTablesAPI(self._api_client)
+        self._permission_migration = PermissionMigrationAPI(self._api_client)
+        self._permissions = PermissionsAPI(self._api_client)
+        self._pipelines = PipelinesAPI(self._api_client)
+        self._policy_compliance_for_clusters = PolicyComplianceForClustersAPI(self._api_client)
+        self._policy_compliance_for_jobs = PolicyComplianceForJobsAPI(self._api_client)
+        self._policy_families = PolicyFamiliesAPI(self._api_client)
+        self._provider_exchange_filters = ProviderExchangeFiltersAPI(self._api_client)
+        self._provider_exchanges = ProviderExchangesAPI(self._api_client)
+        self._provider_files = ProviderFilesAPI(self._api_client)
+        self._provider_listings = ProviderListingsAPI(self._api_client)
+        self._provider_personalization_requests = ProviderPersonalizationRequestsAPI(self._api_client)
+        self._provider_provider_analytics_dashboards = 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_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._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 = ProviderProvidersAPI(self._api_client)
+        self._providers = ProvidersAPI(self._api_client)
+        self._quality_monitors = QualityMonitorsAPI(self._api_client)
+        self._queries = QueriesAPI(self._api_client)
+        self._queries_legacy = QueriesLegacyAPI(self._api_client)
+        self._query_execution = QueryExecutionAPI(self._api_client)
+        self._query_history = QueryHistoryAPI(self._api_client)
+        self._query_visualizations = QueryVisualizationsAPI(self._api_client)
+        self._query_visualizations_legacy = QueryVisualizationsLegacyAPI(self._api_client)
+        self._recipient_activation = RecipientActivationAPI(self._api_client)
+        self._recipients = RecipientsAPI(self._api_client)
+        self._redash_config = RedashConfigAPI(self._api_client)
+        self._registered_models = RegisteredModelsAPI(self._api_client)
+        self._repos = ReposAPI(self._api_client)
+        self._resource_quotas = ResourceQuotasAPI(self._api_client)
+        self._schemas = SchemasAPI(self._api_client)
+        self._secrets = SecretsAPI(self._api_client)
+        self._service_principals = ServicePrincipalsAPI(self._api_client)
         self._serving_endpoints = serving_endpoints
-        self._serving_endpoints_data_plane = service.serving.ServingEndpointsDataPlaneAPI(
-            self._api_client, serving_endpoints)
-        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._serving_endpoints_data_plane = ServingEndpointsDataPlaneAPI(self._api_client, serving_endpoints)
+        self._settings = SettingsAPI(self._api_client)
+        self._shares = SharesAPI(self._api_client)
+        self._statement_execution = StatementExecutionAPI(self._api_client)
+        self._storage_credentials = StorageCredentialsAPI(self._api_client)
+        self._system_schemas = SystemSchemasAPI(self._api_client)
+        self._table_constraints = TableConstraintsAPI(self._api_client)
+        self._tables = TablesAPI(self._api_client)
+        self._temporary_table_credentials = TemporaryTableCredentialsAPI(self._api_client)
+        self._token_management = TokenManagementAPI(self._api_client)
+        self._tokens = TokensAPI(self._api_client)
+        self._users = UsersAPI(self._api_client)
+        self._vector_search_endpoints = VectorSearchEndpointsAPI(self._api_client)
+        self._vector_search_indexes = VectorSearchIndexesAPI(self._api_client)
+        self._volumes = VolumesAPI(self._api_client)
+        self._warehouses = 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._workspace_bindings = WorkspaceBindingsAPI(self._api_client)
+        self._workspace_conf = WorkspaceConfAPI(self._api_client)
 
     @property
     def config(self) -> client.Config:
@@ -305,57 +306,57 @@ class WorkspaceClient:
         return self._dbutils
 
     @property
-    def access_control(self) -> service.iam.AccessControlAPI:
+    def access_control(self) -> 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) -> 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) -> 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) -> AlertsLegacyAPI:
         """The alerts API can be used to perform CRUD operations on alerts."""
         return self._alerts_legacy
 
     @property
-    def apps(self) -> service.apps.AppsAPI:
+    def apps(self) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> ClusterPoliciesAPI:
         """You can use cluster policies to control users' ability to configure clusters based on a set of rules."""
         return self._cluster_policies
 
@@ -365,67 +366,67 @@ class WorkspaceClient:
         return self._clusters
 
     @property
-    def command_execution(self) -> service.compute.CommandExecutionAPI:
+    def command_execution(self) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> DataSourcesAPI:
         """This API is provided to assist you in making new query objects."""
         return self._data_sources
 
@@ -435,67 +436,67 @@ class WorkspaceClient:
         return self._dbfs
 
     @property
-    def dbsql_permissions(self) -> service.sql.DbsqlPermissionsAPI:
+    def dbsql_permissions(self) -> 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) -> 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) -> 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) -> 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) -> FunctionsAPI:
         """Functions implement User-Defined Functions (UDFs) in Unity Catalog."""
         return self._functions
 
     @property
-    def genie(self) -> service.dashboards.GenieAPI:
+    def genie(self) -> 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) -> 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) -> 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) -> GrantsAPI:
         """In Unity Catalog, data is secure by default."""
         return self._grants
 
     @property
-    def groups(self) -> service.iam.GroupsAPI:
+    def groups(self) -> 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) -> 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) -> 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) -> IpAccessListsAPI:
         """IP Access List enables admins to configure IP access lists."""
         return self._ip_access_lists
 
@@ -505,178 +506,192 @@ class WorkspaceClient:
         return self._jobs
 
     @property
-    def lakeview(self) -> service.dashboards.LakeviewAPI:
+    def lakeview(self) -> LakeviewAPI:
         """These APIs provide specific management operations for Lakeview dashboards."""
         return self._lakeview
 
     @property
-    def libraries(self) -> service.compute.LibrariesAPI:
+    def lakeview_embedded(self) -> LakeviewEmbeddedAPI:
+        """Token-based Lakeview APIs for embedding dashboards in external applications."""
+        return self._lakeview_embedded
+
+    @property
+    def libraries(self) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> PolicyFamiliesAPI:
         """View available policy families."""
         return self._policy_families
 
     @property
-    def provider_exchange_filters(self) -> service.marketplace.ProviderExchangeFiltersAPI:
+    def provider_exchange_filters(self) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> ProviderProvidersAPI:
         """Providers are entities that manage assets in Marketplace."""
         return self._provider_providers
 
     @property
-    def providers(self) -> service.sharing.ProvidersAPI:
+    def providers(self) -> 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) -> 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) -> 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) -> QueriesLegacyAPI:
         """These endpoints are used for CRUD operations on query definitions."""
         return self._queries_legacy
 
     @property
-    def query_history(self) -> service.sql.QueryHistoryAPI:
+    def query_execution(self) -> QueryExecutionAPI:
+        """Query execution APIs for AI / BI Dashboards."""
+        return self._query_execution
+
+    @property
+    def query_history(self) -> 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) -> 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) -> 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) -> 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 recipients(self) -> 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 registered_models(self) -> service.catalog.RegisteredModelsAPI:
+    def redash_config(self) -> RedashConfigAPI:
+        """Redash V2 service for workspace configurations (internal)."""
+        return self._redash_config
+
+    @property
+    def registered_models(self) -> 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) -> 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) -> 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) -> 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) -> 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) -> ServicePrincipalsAPI:
         """Identities for use with jobs, automated tools, and systems such as scripts, apps, and CI/CD platforms."""
         return self._service_principals
 
@@ -686,82 +701,82 @@ class WorkspaceClient:
         return self._serving_endpoints
 
     @property
-    def serving_endpoints_data_plane(self) -> service.serving.ServingEndpointsDataPlaneAPI:
+    def serving_endpoints_data_plane(self) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> WarehousesAPI:
         """A SQL warehouse is a compute resource that lets you run SQL commands on data objects within Databricks SQL."""
         return self._warehouses
 
@@ -771,12 +786,12 @@ class WorkspaceClient:
         return self._workspace
 
     @property
-    def workspace_bindings(self) -> service.catalog.WorkspaceBindingsAPI:
+    def workspace_bindings(self) -> 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) -> WorkspaceConfAPI:
         """This API allows updating known workspace settings for advanced users."""
         return self._workspace_conf
 
@@ -850,36 +865,35 @@ class AccountClient:
                                    product_version=product_version)
         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 = AccountAccessControlAPI(self._api_client)
+        self._billable_usage = BillableUsageAPI(self._api_client)
+        self._budget_policy = BudgetPolicyAPI(self._api_client)
+        self._credentials = CredentialsAPI(self._api_client)
+        self._custom_app_integration = CustomAppIntegrationAPI(self._api_client)
+        self._encryption_keys = EncryptionKeysAPI(self._api_client)
+        self._federation_policy = AccountFederationPolicyAPI(self._api_client)
+        self._groups = AccountGroupsAPI(self._api_client)
+        self._ip_access_lists = AccountIpAccessListsAPI(self._api_client)
+        self._log_delivery = LogDeliveryAPI(self._api_client)
+        self._metastore_assignments = AccountMetastoreAssignmentsAPI(self._api_client)
+        self._metastores = AccountMetastoresAPI(self._api_client)
+        self._network_connectivity = NetworkConnectivityAPI(self._api_client)
+        self._networks = NetworksAPI(self._api_client)
+        self._o_auth_published_apps = OAuthPublishedAppsAPI(self._api_client)
+        self._private_access = PrivateAccessAPI(self._api_client)
+        self._published_app_integration = PublishedAppIntegrationAPI(self._api_client)
+        self._service_principal_federation_policy = ServicePrincipalFederationPolicyAPI(self._api_client)
+        self._service_principal_secrets = ServicePrincipalSecretsAPI(self._api_client)
+        self._service_principals = AccountServicePrincipalsAPI(self._api_client)
+        self._settings = AccountSettingsAPI(self._api_client)
+        self._storage = StorageAPI(self._api_client)
+        self._storage_credentials = AccountStorageCredentialsAPI(self._api_client)
+        self._usage_dashboards = UsageDashboardsAPI(self._api_client)
+        self._users = AccountUsersAPI(self._api_client)
+        self._vpc_endpoints = VpcEndpointsAPI(self._api_client)
+        self._workspace_assignment = WorkspaceAssignmentAPI(self._api_client)
+        self._workspaces = WorkspacesAPI(self._api_client)
+        self._budgets = BudgetsAPI(self._api_client)
 
     @property
     def config(self) -> client.Config:
@@ -890,147 +904,147 @@ class AccountClient:
         return self._api_client
 
     @property
-    def access_control(self) -> service.iam.AccountAccessControlAPI:
+    def access_control(self) -> 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) -> 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) -> BudgetPolicyAPI:
         """A service serves REST API about Budget policies."""
         return self._budget_policy
 
     @property
-    def credentials(self) -> service.provisioning.CredentialsAPI:
+    def credentials(self) -> 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) -> 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) -> 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) -> AccountFederationPolicyAPI:
         """These APIs manage account federation policies."""
         return self._federation_policy
 
     @property
-    def groups(self) -> service.iam.AccountGroupsAPI:
+    def groups(self) -> 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) -> 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) -> 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) -> AccountMetastoreAssignmentsAPI:
         """These APIs manage metastore assignments to a workspace."""
         return self._metastore_assignments
 
     @property
-    def metastores(self) -> service.catalog.AccountMetastoresAPI:
+    def metastores(self) -> 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) -> 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 networks(self) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> StorageAPI:
         """These APIs manage storage configurations for this workspace."""
         return self._storage
 
     @property
-    def storage_credentials(self) -> service.catalog.AccountStorageCredentialsAPI:
+    def storage_credentials(self) -> 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) -> UsageDashboardsAPI:
         """These APIs manage usage dashboards for this account."""
         return self._usage_dashboards
 
     @property
-    def users(self) -> service.iam.AccountUsersAPI:
+    def users(self) -> 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) -> 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) -> 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 workspaces(self) -> WorkspacesAPI:
         """These APIs manage workspaces for this account."""
         return self._workspaces
 
     @property
-    def budgets(self) -> service.billing.BudgetsAPI:
+    def budgets(self) -> BudgetsAPI:
         """These APIs manage budget configurations for this account."""
         return self._budgets