databricks-sdk 0.35.0__py3-none-any.whl → 0.37.0__py3-none-any.whl

databricks/sdk/service/sharing.py

@@ -23,418 +23,6 @@ class AuthenticationType(Enum):
     TOKEN = 'TOKEN'
 
 
-@dataclass
-class CentralCleanRoomInfo:
-    clean_room_assets: Optional[List[CleanRoomAssetInfo]] = None
-    """All assets from all collaborators that are available in the clean room. Only one of table_info
-    or notebook_info will be filled in."""
-
-    collaborators: Optional[List[CleanRoomCollaboratorInfo]] = None
-    """All collaborators who are in the clean room."""
-
-    creator: Optional[CleanRoomCollaboratorInfo] = None
-    """The collaborator who created the clean room."""
-
-    station_cloud: Optional[str] = None
-    """The cloud where clean room tasks will be run."""
-
-    station_region: Optional[str] = None
-    """The region where clean room tasks will be run."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CentralCleanRoomInfo into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.clean_room_assets: body['clean_room_assets'] = [v.as_dict() for v in self.clean_room_assets]
-        if self.collaborators: body['collaborators'] = [v.as_dict() for v in self.collaborators]
-        if self.creator: body['creator'] = self.creator.as_dict()
-        if self.station_cloud is not None: body['station_cloud'] = self.station_cloud
-        if self.station_region is not None: body['station_region'] = self.station_region
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CentralCleanRoomInfo:
-        """Deserializes the CentralCleanRoomInfo from a dictionary."""
-        return cls(clean_room_assets=_repeated_dict(d, 'clean_room_assets', CleanRoomAssetInfo),
-                   collaborators=_repeated_dict(d, 'collaborators', CleanRoomCollaboratorInfo),
-                   creator=_from_dict(d, 'creator', CleanRoomCollaboratorInfo),
-                   station_cloud=d.get('station_cloud', None),
-                   station_region=d.get('station_region', None))
-
-
-@dataclass
-class CleanRoomAssetInfo:
-    added_at: Optional[int] = None
-    """Time at which this asset was added, in epoch milliseconds."""
-
-    notebook_info: Optional[CleanRoomNotebookInfo] = None
-    """Details about the notebook asset."""
-
-    owner: Optional[CleanRoomCollaboratorInfo] = None
-    """The collaborator who owns the asset."""
-
-    table_info: Optional[CleanRoomTableInfo] = None
-    """Details about the table asset."""
-
-    updated_at: Optional[int] = None
-    """Time at which this asset was updated, in epoch milliseconds."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CleanRoomAssetInfo into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.added_at is not None: body['added_at'] = self.added_at
-        if self.notebook_info: body['notebook_info'] = self.notebook_info.as_dict()
-        if self.owner: body['owner'] = self.owner.as_dict()
-        if self.table_info: body['table_info'] = self.table_info.as_dict()
-        if self.updated_at is not None: body['updated_at'] = self.updated_at
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CleanRoomAssetInfo:
-        """Deserializes the CleanRoomAssetInfo from a dictionary."""
-        return cls(added_at=d.get('added_at', None),
-                   notebook_info=_from_dict(d, 'notebook_info', CleanRoomNotebookInfo),
-                   owner=_from_dict(d, 'owner', CleanRoomCollaboratorInfo),
-                   table_info=_from_dict(d, 'table_info', CleanRoomTableInfo),
-                   updated_at=d.get('updated_at', None))
-
-
-@dataclass
-class CleanRoomCatalog:
-    catalog_name: Optional[str] = None
-    """Name of the catalog in the clean room station. Empty for notebooks."""
-
-    notebook_files: Optional[List[SharedDataObject]] = None
-    """The details of the shared notebook files."""
-
-    tables: Optional[List[SharedDataObject]] = None
-    """The details of the shared tables."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CleanRoomCatalog into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.catalog_name is not None: body['catalog_name'] = self.catalog_name
-        if self.notebook_files: body['notebook_files'] = [v.as_dict() for v in self.notebook_files]
-        if self.tables: body['tables'] = [v.as_dict() for v in self.tables]
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CleanRoomCatalog:
-        """Deserializes the CleanRoomCatalog from a dictionary."""
-        return cls(catalog_name=d.get('catalog_name', None),
-                   notebook_files=_repeated_dict(d, 'notebook_files', SharedDataObject),
-                   tables=_repeated_dict(d, 'tables', SharedDataObject))
-
-
-@dataclass
-class CleanRoomCatalogUpdate:
-    catalog_name: Optional[str] = None
-    """The name of the catalog to update assets."""
-
-    updates: Optional[SharedDataObjectUpdate] = None
-    """The updates to the assets in the catalog."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CleanRoomCatalogUpdate into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.catalog_name is not None: body['catalog_name'] = self.catalog_name
-        if self.updates: body['updates'] = self.updates.as_dict()
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CleanRoomCatalogUpdate:
-        """Deserializes the CleanRoomCatalogUpdate from a dictionary."""
-        return cls(catalog_name=d.get('catalog_name', None),
-                   updates=_from_dict(d, 'updates', SharedDataObjectUpdate))
-
-
-@dataclass
-class CleanRoomCollaboratorInfo:
-    global_metastore_id: Optional[str] = None
-    """The global Unity Catalog metastore id of the collaborator. Also known as the sharing identifier.
-    The identifier is of format __cloud__:__region__:__metastore-uuid__."""
-
-    organization_name: Optional[str] = None
-    """The organization name of the collaborator. This is configured in the metastore for Delta Sharing
-    and is used to identify the organization to other collaborators."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CleanRoomCollaboratorInfo into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.global_metastore_id is not None: body['global_metastore_id'] = self.global_metastore_id
-        if self.organization_name is not None: body['organization_name'] = self.organization_name
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CleanRoomCollaboratorInfo:
-        """Deserializes the CleanRoomCollaboratorInfo from a dictionary."""
-        return cls(global_metastore_id=d.get('global_metastore_id', None),
-                   organization_name=d.get('organization_name', None))
-
-
-@dataclass
-class CleanRoomInfo:
-    comment: Optional[str] = None
-    """User-provided free-form text description."""
-
-    created_at: Optional[int] = None
-    """Time at which this clean room was created, in epoch milliseconds."""
-
-    created_by: Optional[str] = None
-    """Username of clean room creator."""
-
-    local_catalogs: Optional[List[CleanRoomCatalog]] = None
-    """Catalog aliases shared by the current collaborator with asset details."""
-
-    name: Optional[str] = None
-    """Name of the clean room."""
-
-    owner: Optional[str] = None
-    """Username of current owner of clean room."""
-
-    remote_detailed_info: Optional[CentralCleanRoomInfo] = None
-    """Central clean room details."""
-
-    updated_at: Optional[int] = None
-    """Time at which this clean room was updated, in epoch milliseconds."""
-
-    updated_by: Optional[str] = None
-    """Username of clean room updater."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CleanRoomInfo into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.comment is not None: body['comment'] = self.comment
-        if self.created_at is not None: body['created_at'] = self.created_at
-        if self.created_by is not None: body['created_by'] = self.created_by
-        if self.local_catalogs: body['local_catalogs'] = [v.as_dict() for v in self.local_catalogs]
-        if self.name is not None: body['name'] = self.name
-        if self.owner is not None: body['owner'] = self.owner
-        if self.remote_detailed_info: body['remote_detailed_info'] = self.remote_detailed_info.as_dict()
-        if self.updated_at is not None: body['updated_at'] = self.updated_at
-        if self.updated_by is not None: body['updated_by'] = self.updated_by
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CleanRoomInfo:
-        """Deserializes the CleanRoomInfo from a dictionary."""
-        return cls(comment=d.get('comment', None),
-                   created_at=d.get('created_at', None),
-                   created_by=d.get('created_by', None),
-                   local_catalogs=_repeated_dict(d, 'local_catalogs', CleanRoomCatalog),
-                   name=d.get('name', None),
-                   owner=d.get('owner', None),
-                   remote_detailed_info=_from_dict(d, 'remote_detailed_info', CentralCleanRoomInfo),
-                   updated_at=d.get('updated_at', None),
-                   updated_by=d.get('updated_by', None))
-
-
-@dataclass
-class CleanRoomNotebookInfo:
-    notebook_content: Optional[str] = None
-    """The base64 representation of the notebook content in HTML."""
-
-    notebook_name: Optional[str] = None
-    """The name of the notebook."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CleanRoomNotebookInfo into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.notebook_content is not None: body['notebook_content'] = self.notebook_content
-        if self.notebook_name is not None: body['notebook_name'] = self.notebook_name
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CleanRoomNotebookInfo:
-        """Deserializes the CleanRoomNotebookInfo from a dictionary."""
-        return cls(notebook_content=d.get('notebook_content', None),
-                   notebook_name=d.get('notebook_name', None))
-
-
-@dataclass
-class CleanRoomTableInfo:
-    catalog_name: Optional[str] = None
-    """Name of parent catalog."""
-
-    columns: Optional[List[ColumnInfo]] = None
-    """The array of __ColumnInfo__ definitions of the table's columns."""
-
-    full_name: Optional[str] = None
-    """Full name of table, in form of __catalog_name__.__schema_name__.__table_name__"""
-
-    name: Optional[str] = None
-    """Name of table, relative to parent schema."""
-
-    schema_name: Optional[str] = None
-    """Name of parent schema relative to its parent catalog."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CleanRoomTableInfo into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.catalog_name is not None: body['catalog_name'] = self.catalog_name
-        if self.columns: body['columns'] = [v.as_dict() for v in self.columns]
-        if self.full_name is not None: body['full_name'] = self.full_name
-        if self.name is not None: body['name'] = self.name
-        if self.schema_name is not None: body['schema_name'] = self.schema_name
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CleanRoomTableInfo:
-        """Deserializes the CleanRoomTableInfo from a dictionary."""
-        return cls(catalog_name=d.get('catalog_name', None),
-                   columns=_repeated_dict(d, 'columns', ColumnInfo),
-                   full_name=d.get('full_name', None),
-                   name=d.get('name', None),
-                   schema_name=d.get('schema_name', None))
-
-
-@dataclass
-class ColumnInfo:
-    comment: Optional[str] = None
-    """User-provided free-form text description."""
-
-    mask: Optional[ColumnMask] = None
-
-    name: Optional[str] = None
-    """Name of Column."""
-
-    nullable: Optional[bool] = None
-    """Whether field may be Null (default: true)."""
-
-    partition_index: Optional[int] = None
-    """Partition index for column."""
-
-    position: Optional[int] = None
-    """Ordinal position of column (starting at position 0)."""
-
-    type_interval_type: Optional[str] = None
-    """Format of IntervalType."""
-
-    type_json: Optional[str] = None
-    """Full data type specification, JSON-serialized."""
-
-    type_name: Optional[ColumnTypeName] = None
-    """Name of type (INT, STRUCT, MAP, etc.)."""
-
-    type_precision: Optional[int] = None
-    """Digits of precision; required for DecimalTypes."""
-
-    type_scale: Optional[int] = None
-    """Digits to right of decimal; Required for DecimalTypes."""
-
-    type_text: Optional[str] = None
-    """Full data type specification as SQL/catalogString text."""
-
-    def as_dict(self) -> dict:
-        """Serializes the ColumnInfo into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.comment is not None: body['comment'] = self.comment
-        if self.mask: body['mask'] = self.mask.as_dict()
-        if self.name is not None: body['name'] = self.name
-        if self.nullable is not None: body['nullable'] = self.nullable
-        if self.partition_index is not None: body['partition_index'] = self.partition_index
-        if self.position is not None: body['position'] = self.position
-        if self.type_interval_type is not None: body['type_interval_type'] = self.type_interval_type
-        if self.type_json is not None: body['type_json'] = self.type_json
-        if self.type_name is not None: body['type_name'] = self.type_name.value
-        if self.type_precision is not None: body['type_precision'] = self.type_precision
-        if self.type_scale is not None: body['type_scale'] = self.type_scale
-        if self.type_text is not None: body['type_text'] = self.type_text
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> ColumnInfo:
-        """Deserializes the ColumnInfo from a dictionary."""
-        return cls(comment=d.get('comment', None),
-                   mask=_from_dict(d, 'mask', ColumnMask),
-                   name=d.get('name', None),
-                   nullable=d.get('nullable', None),
-                   partition_index=d.get('partition_index', None),
-                   position=d.get('position', None),
-                   type_interval_type=d.get('type_interval_type', None),
-                   type_json=d.get('type_json', None),
-                   type_name=_enum(d, 'type_name', ColumnTypeName),
-                   type_precision=d.get('type_precision', None),
-                   type_scale=d.get('type_scale', None),
-                   type_text=d.get('type_text', None))
-
-
-@dataclass
-class ColumnMask:
-    function_name: Optional[str] = None
-    """The full name of the column mask SQL UDF."""
-
-    using_column_names: Optional[List[str]] = None
-    """The list of additional table columns to be passed as input to the column mask function. The
-    first arg of the mask function should be of the type of the column being masked and the types of
-    the rest of the args should match the types of columns in 'using_column_names'."""
-
-    def as_dict(self) -> dict:
-        """Serializes the ColumnMask into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.function_name is not None: body['function_name'] = self.function_name
-        if self.using_column_names: body['using_column_names'] = [v for v in self.using_column_names]
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> ColumnMask:
-        """Deserializes the ColumnMask from a dictionary."""
-        return cls(function_name=d.get('function_name', None),
-                   using_column_names=d.get('using_column_names', None))
-
-
-class ColumnTypeName(Enum):
-    """Name of type (INT, STRUCT, MAP, etc.)."""
-
-    ARRAY = 'ARRAY'
-    BINARY = 'BINARY'
-    BOOLEAN = 'BOOLEAN'
-    BYTE = 'BYTE'
-    CHAR = 'CHAR'
-    DATE = 'DATE'
-    DECIMAL = 'DECIMAL'
-    DOUBLE = 'DOUBLE'
-    FLOAT = 'FLOAT'
-    INT = 'INT'
-    INTERVAL = 'INTERVAL'
-    LONG = 'LONG'
-    MAP = 'MAP'
-    NULL = 'NULL'
-    SHORT = 'SHORT'
-    STRING = 'STRING'
-    STRUCT = 'STRUCT'
-    TABLE_TYPE = 'TABLE_TYPE'
-    TIMESTAMP = 'TIMESTAMP'
-    TIMESTAMP_NTZ = 'TIMESTAMP_NTZ'
-    USER_DEFINED_TYPE = 'USER_DEFINED_TYPE'
-
-
-@dataclass
-class CreateCleanRoom:
-    name: str
-    """Name of the clean room."""
-
-    remote_detailed_info: CentralCleanRoomInfo
-    """Central clean room details."""
-
-    comment: Optional[str] = None
-    """User-provided free-form text description."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateCleanRoom into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.comment is not None: body['comment'] = self.comment
-        if self.name is not None: body['name'] = self.name
-        if self.remote_detailed_info: body['remote_detailed_info'] = self.remote_detailed_info.as_dict()
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> CreateCleanRoom:
-        """Deserializes the CreateCleanRoom from a dictionary."""
-        return cls(comment=d.get('comment', None),
-                   name=d.get('name', None),
-                   remote_detailed_info=_from_dict(d, 'remote_detailed_info', CentralCleanRoomInfo))
-
-
 @dataclass
 class CreateProvider:
     name: str
@@ -623,29 +211,6 @@ class IpAccessList:
         return cls(allowed_ip_addresses=d.get('allowed_ip_addresses', None))
 
 
-@dataclass
-class ListCleanRoomsResponse:
-    clean_rooms: Optional[List[CleanRoomInfo]] = None
-    """An array of clean rooms. Remote details (central) are not included."""
-
-    next_page_token: Optional[str] = None
-    """Opaque token to retrieve the next page of results. Absent if there are no more pages.
-    __page_token__ should be set to this value for the next request (for the next page of results)."""
-
-    def as_dict(self) -> dict:
-        """Serializes the ListCleanRoomsResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.clean_rooms: body['clean_rooms'] = [v.as_dict() for v in self.clean_rooms]
-        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]) -> ListCleanRoomsResponse:
-        """Deserializes the ListCleanRoomsResponse from a dictionary."""
-        return cls(clean_rooms=_repeated_dict(d, 'clean_rooms', CleanRoomInfo),
-                   next_page_token=d.get('next_page_token', None))
-
-
 @dataclass
 class ListProviderSharesResponse:
     next_page_token: Optional[str] = None
@@ -1473,38 +1038,6 @@ class SharedDataObjectUpdateAction(Enum):
     UPDATE = 'UPDATE'
 
 
-@dataclass
-class UpdateCleanRoom:
-    catalog_updates: Optional[List[CleanRoomCatalogUpdate]] = None
-    """Array of shared data object updates."""
-
-    comment: Optional[str] = None
-    """User-provided free-form text description."""
-
-    name: Optional[str] = None
-    """The name of the clean room."""
-
-    owner: Optional[str] = None
-    """Username of current owner of clean room."""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateCleanRoom into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.catalog_updates: body['catalog_updates'] = [v.as_dict() for v in self.catalog_updates]
-        if self.comment is not None: body['comment'] = self.comment
-        if self.name is not None: body['name'] = self.name
-        if self.owner is not None: body['owner'] = self.owner
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, any]) -> UpdateCleanRoom:
-        """Deserializes the UpdateCleanRoom from a dictionary."""
-        return cls(catalog_updates=_repeated_dict(d, 'catalog_updates', CleanRoomCatalogUpdate),
-                   comment=d.get('comment', None),
-                   name=d.get('name', None),
-                   owner=d.get('owner', None))
-
-
 @dataclass
 class UpdatePermissionsResponse:
 
@@ -1699,157 +1232,6 @@ class UpdateSharePermissions:
                    page_token=d.get('page_token', None))
 
 
-class CleanRoomsAPI:
-    """A clean room is a secure, privacy-protecting environment where two or more parties can share sensitive
-    enterprise data, including customer data, for measurements, insights, activation and other use cases.
-    
-    To create clean rooms, you must be a metastore admin or a user with the **CREATE_CLEAN_ROOM** privilege."""
-
-    def __init__(self, api_client):
-        self._api = api_client
-
-    def create(self,
-               name: str,
-               remote_detailed_info: CentralCleanRoomInfo,
-               *,
-               comment: Optional[str] = None) -> CleanRoomInfo:
-        """Create a clean room.
-        
-        Creates a new clean room with specified colaborators. The caller must be a metastore admin or have the
-        **CREATE_CLEAN_ROOM** privilege on the metastore.
-        
-        :param name: str
-          Name of the clean room.
-        :param remote_detailed_info: :class:`CentralCleanRoomInfo`
-          Central clean room details.
-        :param comment: str (optional)
-          User-provided free-form text description.
-        
-        :returns: :class:`CleanRoomInfo`
-        """
-        body = {}
-        if comment is not None: body['comment'] = comment
-        if name is not None: body['name'] = name
-        if remote_detailed_info is not None: body['remote_detailed_info'] = remote_detailed_info.as_dict()
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
-
-        res = self._api.do('POST', '/api/2.1/unity-catalog/clean-rooms', body=body, headers=headers)
-        return CleanRoomInfo.from_dict(res)
-
-    def delete(self, name: str):
-        """Delete a clean room.
-        
-        Deletes a data object clean room from the metastore. The caller must be an owner of the clean room.
-        
-        :param name: str
-          The name of the clean room.
-        
-        
-        """
-
-        headers = {'Accept': 'application/json', }
-
-        self._api.do('DELETE', f'/api/2.1/unity-catalog/clean-rooms/{name}', headers=headers)
-
-    def get(self, name: str, *, include_remote_details: Optional[bool] = None) -> CleanRoomInfo:
-        """Get a clean room.
-        
-        Gets a data object clean room from the metastore. The caller must be a metastore admin or the owner of
-        the clean room.
-        
-        :param name: str
-          The name of the clean room.
-        :param include_remote_details: bool (optional)
-          Whether to include remote details (central) on the clean room.
-        
-        :returns: :class:`CleanRoomInfo`
-        """
-
-        query = {}
-        if include_remote_details is not None: query['include_remote_details'] = include_remote_details
-        headers = {'Accept': 'application/json', }
-
-        res = self._api.do('GET', f'/api/2.1/unity-catalog/clean-rooms/{name}', query=query, headers=headers)
-        return CleanRoomInfo.from_dict(res)
-
-    def list(self,
-             *,
-             max_results: Optional[int] = None,
-             page_token: Optional[str] = None) -> Iterator[CleanRoomInfo]:
-        """List clean rooms.
-        
-        Gets an array of data object clean rooms from the metastore. The caller must be a metastore admin or
-        the owner of the clean room. There is no guarantee of a specific ordering of the elements in the
-        array.
-        
-        :param max_results: int (optional)
-          Maximum number of clean rooms to return. If not set, all the clean rooms are returned (not
-          recommended). - when set to a value greater than 0, the page length is the minimum of this value and
-          a server configured value; - when set to 0, the page length is set to a server configured value
-          (recommended); - when set to a value less than 0, an invalid parameter error is returned;
-        :param page_token: str (optional)
-          Opaque pagination token to go to next page based on previous query.
-        
-        :returns: Iterator over :class:`CleanRoomInfo`
-        """
-
-        query = {}
-        if max_results is not None: query['max_results'] = max_results
-        if page_token is not None: query['page_token'] = page_token
-        headers = {'Accept': 'application/json', }
-
-        while True:
-            json = self._api.do('GET', '/api/2.1/unity-catalog/clean-rooms', query=query, headers=headers)
-            if 'clean_rooms' in json:
-                for v in json['clean_rooms']:
-                    yield CleanRoomInfo.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(self,
-               name: str,
-               *,
-               catalog_updates: Optional[List[CleanRoomCatalogUpdate]] = None,
-               comment: Optional[str] = None,
-               owner: Optional[str] = None) -> CleanRoomInfo:
-        """Update a clean room.
-        
-        Updates the clean room with the changes and data objects in the request. The caller must be the owner
-        of the clean room or a metastore admin.
-        
-        When the caller is a metastore admin, only the __owner__ field can be updated.
-        
-        In the case that the clean room name is changed **updateCleanRoom** requires that the caller is both
-        the clean room owner and a metastore admin.
-        
-        For each table that is added through this method, the clean room owner must also have **SELECT**
-        privilege on the table. The privilege must be maintained indefinitely for recipients to be able to
-        access the table. Typically, you should use a group as the clean room owner.
-        
-        Table removals through **update** do not require additional privileges.
-        
-        :param name: str
-          The name of the clean room.
-        :param catalog_updates: List[:class:`CleanRoomCatalogUpdate`] (optional)
-          Array of shared data object updates.
-        :param comment: str (optional)
-          User-provided free-form text description.
-        :param owner: str (optional)
-          Username of current owner of clean room.
-        
-        :returns: :class:`CleanRoomInfo`
-        """
-        body = {}
-        if catalog_updates is not None: body['catalog_updates'] = [v.as_dict() for v in catalog_updates]
-        if comment is not None: body['comment'] = comment
-        if owner is not None: body['owner'] = owner
-        headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
-
-        res = self._api.do('PATCH', f'/api/2.1/unity-catalog/clean-rooms/{name}', body=body, headers=headers)
-        return CleanRoomInfo.from_dict(res)
-
-
 class ProvidersAPI:
     """A data provider is an object representing the organization in the real world who shares the data. A
     provider contains shares which further contain the shared data."""

databricks/sdk/service/sql.py

@@ -507,7 +507,7 @@ class ChannelName(Enum):
     CHANNEL_NAME_CURRENT = 'CHANNEL_NAME_CURRENT'
     CHANNEL_NAME_CUSTOM = 'CHANNEL_NAME_CUSTOM'
     CHANNEL_NAME_PREVIEW = 'CHANNEL_NAME_PREVIEW'
-    CHANNEL_NAME_UNSPECIFIED = 'CHANNEL_NAME_UNSPECIFIED'
+    CHANNEL_NAME_PREVIOUS = 'CHANNEL_NAME_PREVIOUS'
 
 
 @dataclass
@@ -6579,11 +6579,10 @@ class StatementExecutionAPI:
     outstanding statement might have already completed execution when the cancel request arrives. Polling for
     status until a terminal state is reached is a reliable way to determine the final state. - Wait timeouts
     are approximate, occur server-side, and cannot account for things such as caller delays and network
-    latency from caller to service. - The system will auto-close a statement after one hour if the client
-    stops polling and thus you must poll at least once an hour. - The results are only available for one hour
-    after success; polling does not extend this. - The SQL Execution API must be used for the entire lifecycle
-    of the statement. For example, you cannot use the Jobs API to execute the command, and then the SQL
-    Execution API to cancel it.
+    latency from caller to service. - To guarantee that the statement is kept alive, you must poll at least
+    once every 15 minutes. - The results are only available for one hour after success; polling does not
+    extend this. - The SQL Execution API must be used for the entire lifecycle of the statement. For example,
+    you cannot use the Jobs API to execute the command, and then the SQL Execution API to cancel it.
     
     [Apache Arrow Columnar]: https://arrow.apache.org/overview/
     [Databricks SQL Statement Execution API tutorial]: https://docs.databricks.com/sql/api/sql-execution-tutorial.html"""
@@ -7243,7 +7242,8 @@ class WarehousesAPI:
                         ) -> WarehousePermissions:
         """Set SQL warehouse permissions.
         
-        Sets permissions on a SQL warehouse. SQL warehouses can inherit permissions from their root object.
+        Sets permissions on an object, replacing existing permissions if they exist. Deletes all direct
+        permissions if none are specified. Objects can inherit permissions from their root object.
         
         :param warehouse_id: str
           The SQL warehouse for which to get or manage permissions.