databricks-sdk 0.62.0__py3-none-any.whl → 0.64.0__py3-none-any.whl

databricks/sdk/service/cleanrooms.py

@@ -45,7 +45,7 @@ class CleanRoom:
     using the separate CreateCleanRoomOutputCatalog API."""
 
     owner: Optional[str] = None
-    """This is Databricks username of the owner of the local clean room securable for permission
+    """This is the Databricks username of the owner of the local clean room securable for permission
     management."""
 
     remote_detailed_info: Optional[CleanRoomRemoteDetail] = None
@@ -142,7 +142,8 @@ class CleanRoomAsset:
     For UC securable assets (tables, volumes, etc.), the format is
     *shared_catalog*.*shared_schema*.*asset_name*
     
-    For notebooks, the name is the notebook file name."""
+    For notebooks, the name is the notebook file name. For jar analyses, the name is the jar
+    analysis name."""
 
     asset_type: CleanRoomAssetAssetType
     """The type of the asset."""
@@ -351,13 +352,13 @@ class CleanRoomAssetNotebook:
     """Server generated etag that represents the notebook version."""
 
     review_state: Optional[CleanRoomNotebookReviewNotebookReviewState] = None
-    """top-level status derived from all reviews"""
+    """Top-level status derived from all reviews"""
 
     reviews: Optional[List[CleanRoomNotebookReview]] = None
     """All existing approvals or rejections"""
 
     runner_collaborator_aliases: Optional[List[str]] = None
-    """collaborators that can run the notebook"""
+    """Aliases of collaborators that can run the notebook."""
 
     def as_dict(self) -> dict:
         """Serializes the CleanRoomAssetNotebook into a dictionary suitable for use as a JSON request body."""
@@ -546,8 +547,12 @@ class CleanRoomAssetVolumeLocalDetails:
 @dataclass
 class CleanRoomAutoApprovalRule:
     author_collaborator_alias: Optional[str] = None
+    """Collaborator alias of the author covered by the rule. Only one of `author_collaborator_alias`
+    and `author_scope` can be set."""
 
     author_scope: Optional[CleanRoomAutoApprovalRuleAuthorScope] = None
+    """Scope of authors covered by the rule. Only one of `author_collaborator_alias` and `author_scope`
+    can be set."""
 
     clean_room_name: Optional[str] = None
     """The name of the clean room this auto-approval rule belongs to."""
@@ -562,6 +567,7 @@ class CleanRoomAutoApprovalRule:
     """The owner of the rule to whom the rule applies."""
 
     runner_collaborator_alias: Optional[str] = None
+    """Collaborator alias of the runner covered by the rule."""
 
     def as_dict(self) -> dict:
         """Serializes the CleanRoomAutoApprovalRule into a dictionary suitable for use as a JSON request body."""
@@ -637,7 +643,7 @@ class CleanRoomCollaborator:
     It is not restricted to these values and could change in the future"""
 
     global_metastore_id: Optional[str] = None
-    """The global Unity Catalog metastore id of the collaborator. The identifier is of format
+    """The global Unity Catalog metastore ID of the collaborator. The identifier is of format
     cloud:region:metastore-uuid."""
 
     invite_recipient_email: Optional[str] = None
@@ -704,19 +710,19 @@ class CleanRoomCollaborator:
 @dataclass
 class CleanRoomNotebookReview:
     comment: Optional[str] = None
-    """review comment"""
+    """Review comment"""
 
     created_at_millis: Optional[int] = None
-    """timestamp of when the review was submitted"""
+    """When the review was submitted, in epoch milliseconds"""
 
     review_state: Optional[CleanRoomNotebookReviewNotebookReviewState] = None
-    """review outcome"""
+    """Review outcome"""
 
     review_sub_reason: Optional[CleanRoomNotebookReviewNotebookReviewSubReason] = None
-    """specified when the review was not explicitly made by a user"""
+    """Specified when the review was not explicitly made by a user"""
 
     reviewer_collaborator_alias: Optional[str] = None
-    """collaborator alias of the reviewer"""
+    """Collaborator alias of the reviewer"""
 
     def as_dict(self) -> dict:
         """Serializes the CleanRoomNotebookReview into a dictionary suitable for use as a JSON request body."""
@@ -1100,7 +1106,7 @@ class ComplianceSecurityProfile:
 @dataclass
 class CreateCleanRoomAssetReviewResponse:
     notebook_review_state: Optional[CleanRoomNotebookReviewNotebookReviewState] = None
-    """top-level status derived from all reviews"""
+    """Top-level status derived from all reviews"""
 
     notebook_reviews: Optional[List[CleanRoomNotebookReview]] = None
     """All existing notebook approvals or rejections"""
@@ -1348,13 +1354,13 @@ class ListCleanRoomsResponse:
 @dataclass
 class NotebookVersionReview:
     etag: str
-    """etag that identifies the notebook version"""
+    """Etag identifying the notebook version"""
 
     review_state: CleanRoomNotebookReviewNotebookReviewState
-    """review outcome"""
+    """Review outcome"""
 
     comment: Optional[str] = None
-    """review comment"""
+    """Review comment"""
 
     def as_dict(self) -> dict:
         """Serializes the NotebookVersionReview into a dictionary suitable for use as a JSON request body."""
@@ -1505,12 +1511,12 @@ class CleanRoomAssetsAPI:
         name: str,
         notebook_review: NotebookVersionReview,
     ) -> CreateCleanRoomAssetReviewResponse:
-        """submit an asset review
+        """Submit an asset review
 
         :param clean_room_name: str
           Name of the clean room
         :param asset_type: :class:`CleanRoomAssetAssetType`
-          can only be NOTEBOOK_FILE for now
+          Asset type. Can only be NOTEBOOK_FILE.
         :param name: str
           Name of the asset
         :param notebook_review: :class:`NotebookVersionReview`
@@ -1620,7 +1626,8 @@ class CleanRoomAssetsAPI:
           For UC securable assets (tables, volumes, etc.), the format is
           *shared_catalog*.*shared_schema*.*asset_name*
 
-          For notebooks, the name is the notebook file name.
+          For notebooks, the name is the notebook file name. For jar analyses, the name is the jar analysis
+          name.
         :param asset: :class:`CleanRoomAsset`
           The asset to update. The asset's `name` and `asset_type` fields are used to identify the asset to
           update.

databricks/sdk/service/compute.py

@@ -3410,6 +3410,15 @@ class GcpAttributes:
     boot_disk_size: Optional[int] = None
     """Boot disk size in GB"""
 
+    first_on_demand: Optional[int] = None
+    """The first `first_on_demand` nodes of the cluster will be placed on on-demand instances. This
+    value should be greater than 0, to make sure the cluster driver node is placed on an on-demand
+    instance. If this value is greater than or equal to the current cluster size, all nodes will be
+    placed on on-demand instances. If this value is less than the current cluster size,
+    `first_on_demand` nodes will be placed on on-demand instances and the remainder will be placed
+    on `availability` instances. Note that this value does not affect cluster size and cannot
+    currently be mutated over the lifetime of a cluster."""
+
     google_service_account: Optional[str] = None
     """If provided, the cluster will impersonate the google service account when accessing gcloud
     services (like GCS). The google service account must have previously been added to the
@@ -3441,6 +3450,8 @@ class GcpAttributes:
             body["availability"] = self.availability.value
         if self.boot_disk_size is not None:
             body["boot_disk_size"] = self.boot_disk_size
+        if self.first_on_demand is not None:
+            body["first_on_demand"] = self.first_on_demand
         if self.google_service_account is not None:
             body["google_service_account"] = self.google_service_account
         if self.local_ssd_count is not None:
@@ -3458,6 +3469,8 @@ class GcpAttributes:
             body["availability"] = self.availability
         if self.boot_disk_size is not None:
             body["boot_disk_size"] = self.boot_disk_size
+        if self.first_on_demand is not None:
+            body["first_on_demand"] = self.first_on_demand
         if self.google_service_account is not None:
             body["google_service_account"] = self.google_service_account
         if self.local_ssd_count is not None:
@@ -3474,6 +3487,7 @@ class GcpAttributes:
         return cls(
             availability=_enum(d, "availability", GcpAvailability),
             boot_disk_size=d.get("boot_disk_size", None),
+            first_on_demand=d.get("first_on_demand", None),
             google_service_account=d.get("google_service_account", None),
             local_ssd_count=d.get("local_ssd_count", None),
             use_preemptible_executors=d.get("use_preemptible_executors", None),

databricks/sdk/service/dashboards.py

@@ -413,6 +413,14 @@ class GenieConversationSummary:
         )
 
 
+class GenieFeedbackRating(Enum):
+    """Feedback rating for Genie messages"""
+
+    NEGATIVE = "NEGATIVE"
+    NONE = "NONE"
+    POSITIVE = "POSITIVE"
+
+
 @dataclass
 class GenieGetMessageQueryResultResponse:
     statement_response: Optional[sql.StatementResponse] = None
@@ -439,6 +447,38 @@ class GenieGetMessageQueryResultResponse:
         return cls(statement_response=_from_dict(d, "statement_response", sql.StatementResponse))
 
 
+@dataclass
+class GenieListConversationMessagesResponse:
+    messages: Optional[List[GenieMessage]] = None
+    """List of messages in the conversation."""
+
+    next_page_token: Optional[str] = None
+    """The token to use for retrieving the next page of results."""
+
+    def as_dict(self) -> dict:
+        """Serializes the GenieListConversationMessagesResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.messages:
+            body["messages"] = [v.as_dict() for v in self.messages]
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GenieListConversationMessagesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.messages:
+            body["messages"] = self.messages
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> GenieListConversationMessagesResponse:
+        """Deserializes the GenieListConversationMessagesResponse from a dictionary."""
+        return cls(messages=_repeated_dict(d, "messages", GenieMessage), next_page_token=d.get("next_page_token", None))
+
+
 @dataclass
 class GenieListConversationsResponse:
     conversations: Optional[List[GenieConversationSummary]] = None
@@ -1630,6 +1670,29 @@ class GenieAPI:
 
         self._api.do("DELETE", f"/api/2.0/genie/spaces/{space_id}/conversations/{conversation_id}", headers=headers)
 
+    def delete_conversation_message(self, space_id: str, conversation_id: str, message_id: str):
+        """Delete a conversation message.
+
+        :param space_id: str
+          The ID associated with the Genie space where the message is located.
+        :param conversation_id: str
+          The ID associated with the conversation.
+        :param message_id: str
+          The ID associated with the message to delete.
+
+
+        """
+
+        headers = {
+            "Accept": "application/json",
+        }
+
+        self._api.do(
+            "DELETE",
+            f"/api/2.0/genie/spaces/{space_id}/conversations/{conversation_id}/messages/{message_id}",
+            headers=headers,
+        )
+
     def execute_message_attachment_query(
         self, space_id: str, conversation_id: str, message_id: str, attachment_id: str
     ) -> GenieGetMessageQueryResultResponse:
@@ -1662,7 +1725,8 @@ class GenieAPI:
     def execute_message_query(
         self, space_id: str, conversation_id: str, message_id: str
     ) -> GenieGetMessageQueryResultResponse:
-        """Execute the SQL query in the message.
+        """DEPRECATED: Use [Execute Message Attachment Query](:method:genie/executemessageattachmentquery)
+        instead.
 
         :param space_id: str
           Genie space ID
@@ -1741,8 +1805,8 @@ class GenieAPI:
     def get_message_query_result(
         self, space_id: str, conversation_id: str, message_id: str
     ) -> GenieGetMessageQueryResultResponse:
-        """Get the result of SQL query if the message has a query attachment. This is only available if a message
-        has a query attachment and the message status is `EXECUTING_QUERY`.
+        """DEPRECATED: Use [Get Message Attachment Query Result](:method:genie/getmessageattachmentqueryresult)
+        instead.
 
         :param space_id: str
           Genie space ID
@@ -1768,8 +1832,8 @@ class GenieAPI:
     def get_message_query_result_by_attachment(
         self, space_id: str, conversation_id: str, message_id: str, attachment_id: str
     ) -> GenieGetMessageQueryResultResponse:
-        """Get the result of SQL query if the message has a query attachment. This is only available if a message
-        has a query attachment and the message status is `EXECUTING_QUERY` OR `COMPLETED`.
+        """DEPRECATED: Use [Get Message Attachment Query Result](:method:genie/getmessageattachmentqueryresult)
+        instead.
 
         :param space_id: str
           Genie space ID
@@ -1810,13 +1874,55 @@ class GenieAPI:
         res = self._api.do("GET", f"/api/2.0/genie/spaces/{space_id}", headers=headers)
         return GenieSpace.from_dict(res)
 
+    def list_conversation_messages(
+        self, space_id: str, conversation_id: str, *, page_size: Optional[int] = None, page_token: Optional[str] = None
+    ) -> GenieListConversationMessagesResponse:
+        """List messages in a conversation
+
+        :param space_id: str
+          The ID associated with the Genie space where the conversation is located
+        :param conversation_id: str
+          The ID of the conversation to list messages from
+        :param page_size: int (optional)
+          Maximum number of messages to return per page
+        :param page_token: str (optional)
+          Token to get the next page of results
+
+        :returns: :class:`GenieListConversationMessagesResponse`
+        """
+
+        query = {}
+        if page_size is not None:
+            query["page_size"] = page_size
+        if page_token is not None:
+            query["page_token"] = page_token
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do(
+            "GET",
+            f"/api/2.0/genie/spaces/{space_id}/conversations/{conversation_id}/messages",
+            query=query,
+            headers=headers,
+        )
+        return GenieListConversationMessagesResponse.from_dict(res)
+
     def list_conversations(
-        self, space_id: str, *, page_size: Optional[int] = None, page_token: Optional[str] = None
+        self,
+        space_id: str,
+        *,
+        include_all: Optional[bool] = None,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
     ) -> GenieListConversationsResponse:
         """Get a list of conversations in a Genie Space.
 
         :param space_id: str
           The ID of the Genie space to retrieve conversations from.
+        :param include_all: bool (optional)
+          Include all conversations in the space across all users. Requires "Can Manage" permission on the
+          space.
         :param page_size: int (optional)
           Maximum number of conversations to return per page
         :param page_token: str (optional)
@@ -1826,6 +1932,8 @@ class GenieAPI:
         """
 
         query = {}
+        if include_all is not None:
+            query["include_all"] = include_all
         if page_size is not None:
             query["page_size"] = page_size
         if page_token is not None:
@@ -1862,6 +1970,47 @@ class GenieAPI:
         res = self._api.do("GET", "/api/2.0/genie/spaces", query=query, headers=headers)
         return GenieListSpacesResponse.from_dict(res)
 
+    def send_message_feedback(
+        self,
+        space_id: str,
+        conversation_id: str,
+        message_id: str,
+        feedback_rating: GenieFeedbackRating,
+        *,
+        feedback_text: Optional[str] = None,
+    ):
+        """Send feedback for a message.
+
+        :param space_id: str
+          The ID associated with the Genie space where the message is located.
+        :param conversation_id: str
+          The ID associated with the conversation.
+        :param message_id: str
+          The ID associated with the message to provide feedback for.
+        :param feedback_rating: :class:`GenieFeedbackRating`
+          The rating (POSITIVE, NEGATIVE, or NONE).
+        :param feedback_text: str (optional)
+          Optional text feedback that will be stored as a comment.
+
+
+        """
+        body = {}
+        if feedback_rating is not None:
+            body["feedback_rating"] = feedback_rating.value
+        if feedback_text is not None:
+            body["feedback_text"] = feedback_text
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        self._api.do(
+            "POST",
+            f"/api/2.0/genie/spaces/{space_id}/conversations/{conversation_id}/messages/{message_id}/feedback",
+            body=body,
+            headers=headers,
+        )
+
     def start_conversation(self, space_id: str, content: str) -> Wait[GenieMessage]:
         """Start a new conversation.
 

databricks/sdk/service/database.py

@@ -589,6 +589,40 @@ class DeltaTableSyncInfo:
         )
 
 
+@dataclass
+class ListDatabaseCatalogsResponse:
+    database_catalogs: Optional[List[DatabaseCatalog]] = None
+
+    next_page_token: Optional[str] = None
+    """Pagination token to request the next page of database catalogs."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ListDatabaseCatalogsResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.database_catalogs:
+            body["database_catalogs"] = [v.as_dict() for v in self.database_catalogs]
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListDatabaseCatalogsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.database_catalogs:
+            body["database_catalogs"] = self.database_catalogs
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ListDatabaseCatalogsResponse:
+        """Deserializes the ListDatabaseCatalogsResponse from a dictionary."""
+        return cls(
+            database_catalogs=_repeated_dict(d, "database_catalogs", DatabaseCatalog),
+            next_page_token=d.get("next_page_token", None),
+        )
+
+
 @dataclass
 class ListDatabaseInstanceRolesResponse:
     database_instance_roles: Optional[List[DatabaseInstanceRole]] = None
@@ -659,6 +693,40 @@ class ListDatabaseInstancesResponse:
         )
 
 
+@dataclass
+class ListSyncedDatabaseTablesResponse:
+    next_page_token: Optional[str] = None
+    """Pagination token to request the next page of synced tables."""
+
+    synced_tables: Optional[List[SyncedDatabaseTable]] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the ListSyncedDatabaseTablesResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        if self.synced_tables:
+            body["synced_tables"] = [v.as_dict() for v in self.synced_tables]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListSyncedDatabaseTablesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        if self.synced_tables:
+            body["synced_tables"] = self.synced_tables
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ListSyncedDatabaseTablesResponse:
+        """Deserializes the ListSyncedDatabaseTablesResponse from a dictionary."""
+        return cls(
+            next_page_token=d.get("next_page_token", None),
+            synced_tables=_repeated_dict(d, "synced_tables", SyncedDatabaseTable),
+        )
+
+
 @dataclass
 class NewPipelineSpec:
     """Custom fields that user can set for pipeline while creating SyncedDatabaseTable. Note that other
@@ -1733,10 +1801,47 @@ class DatabaseAPI:
         res = self._api.do("GET", f"/api/2.0/database/synced_tables/{name}", headers=headers)
         return SyncedDatabaseTable.from_dict(res)
 
+    def list_database_catalogs(
+        self, instance_name: str, *, page_size: Optional[int] = None, page_token: Optional[str] = None
+    ) -> Iterator[DatabaseCatalog]:
+        """This API is currently unimplemented, but exposed for Terraform support.
+
+        :param instance_name: str
+          Name of the instance to get database catalogs for.
+        :param page_size: int (optional)
+          Upper bound for items returned.
+        :param page_token: str (optional)
+          Pagination token to go to the next page of synced database tables. Requests first page if absent.
+
+        :returns: Iterator over :class:`DatabaseCatalog`
+        """
+
+        query = {}
+        if page_size is not None:
+            query["page_size"] = page_size
+        if page_token is not None:
+            query["page_token"] = page_token
+        headers = {
+            "Accept": "application/json",
+        }
+
+        while True:
+            json = self._api.do(
+                "GET", f"/api/2.0/database/instances/{instance_name}/catalogs", query=query, headers=headers
+            )
+            if "database_catalogs" in json:
+                for v in json["database_catalogs"]:
+                    yield DatabaseCatalog.from_dict(v)
+            if "next_page_token" not in json or not json["next_page_token"]:
+                return
+            query["page_token"] = json["next_page_token"]
+
     def list_database_instance_roles(
         self, instance_name: str, *, page_size: Optional[int] = None, page_token: Optional[str] = None
     ) -> Iterator[DatabaseInstanceRole]:
-        """START OF PG ROLE APIs Section
+        """START OF PG ROLE APIs Section These APIs are marked a PUBLIC with stage < PUBLIC_PREVIEW. With more
+        recent Lakebase V2 plans, we don't plan to ever advance these to PUBLIC_PREVIEW. These APIs will
+        remain effectively undocumented/UI-only and we'll aim for a new public roles API as part of V2 PuPr.
 
         :param instance_name: str
         :param page_size: int (optional)
@@ -1798,6 +1903,67 @@ class DatabaseAPI:
                 return
             query["page_token"] = json["next_page_token"]
 
+    def list_synced_database_tables(
+        self, instance_name: str, *, page_size: Optional[int] = None, page_token: Optional[str] = None
+    ) -> Iterator[SyncedDatabaseTable]:
+        """This API is currently unimplemented, but exposed for Terraform support.
+
+        :param instance_name: str
+          Name of the instance to get synced tables for.
+        :param page_size: int (optional)
+          Upper bound for items returned.
+        :param page_token: str (optional)
+          Pagination token to go to the next page of synced database tables. Requests first page if absent.
+
+        :returns: Iterator over :class:`SyncedDatabaseTable`
+        """
+
+        query = {}
+        if page_size is not None:
+            query["page_size"] = page_size
+        if page_token is not None:
+            query["page_token"] = page_token
+        headers = {
+            "Accept": "application/json",
+        }
+
+        while True:
+            json = self._api.do(
+                "GET", f"/api/2.0/database/instances/{instance_name}/synced_tables", query=query, headers=headers
+            )
+            if "synced_tables" in json:
+                for v in json["synced_tables"]:
+                    yield SyncedDatabaseTable.from_dict(v)
+            if "next_page_token" not in json or not json["next_page_token"]:
+                return
+            query["page_token"] = json["next_page_token"]
+
+    def update_database_catalog(
+        self, name: str, database_catalog: DatabaseCatalog, update_mask: str
+    ) -> DatabaseCatalog:
+        """This API is currently unimplemented, but exposed for Terraform support.
+
+        :param name: str
+          The name of the catalog in UC.
+        :param database_catalog: :class:`DatabaseCatalog`
+          Note that updating a database catalog is not yet supported.
+        :param update_mask: str
+          The list of fields to update. Setting this field is not yet supported.
+
+        :returns: :class:`DatabaseCatalog`
+        """
+        body = database_catalog.as_dict()
+        query = {}
+        if update_mask is not None:
+            query["update_mask"] = update_mask
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do("PATCH", f"/api/2.0/database/catalogs/{name}", query=query, body=body, headers=headers)
+        return DatabaseCatalog.from_dict(res)
+
     def update_database_instance(
         self, name: str, database_instance: DatabaseInstance, update_mask: str
     ) -> DatabaseInstance:
@@ -1807,7 +1973,8 @@ class DatabaseAPI:
           The name of the instance. This is the unique identifier for the instance.
         :param database_instance: :class:`DatabaseInstance`
         :param update_mask: str
-          The list of fields to update. This field is not yet supported, and is ignored by the server.
+          The list of fields to update. If unspecified, all fields will be updated when possible. To wipe out
+          custom_tags, specify custom_tags in the update_mask with an empty custom_tags map.
 
         :returns: :class:`DatabaseInstance`
         """
@@ -1822,3 +1989,29 @@ class DatabaseAPI:
 
         res = self._api.do("PATCH", f"/api/2.0/database/instances/{name}", query=query, body=body, headers=headers)
         return DatabaseInstance.from_dict(res)
+
+    def update_synced_database_table(
+        self, name: str, synced_table: SyncedDatabaseTable, update_mask: str
+    ) -> SyncedDatabaseTable:
+        """This API is currently unimplemented, but exposed for Terraform support.
+
+        :param name: str
+          Full three-part (catalog, schema, table) name of the table.
+        :param synced_table: :class:`SyncedDatabaseTable`
+          Note that updating a synced database table is not yet supported.
+        :param update_mask: str
+          The list of fields to update. Setting this field is not yet supported.
+
+        :returns: :class:`SyncedDatabaseTable`
+        """
+        body = synced_table.as_dict()
+        query = {}
+        if update_mask is not None:
+            query["update_mask"] = update_mask
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do("PATCH", f"/api/2.0/database/synced_tables/{name}", query=query, body=body, headers=headers)
+        return SyncedDatabaseTable.from_dict(res)