databricks-sdk 0.67.0__py3-none-any.whl → 0.68.0__py3-none-any.whl

databricks/sdk/service/catalog.py

@@ -10,8 +10,10 @@ from datetime import timedelta
 from enum import Enum
 from typing import Any, Callable, Dict, Iterator, List, Optional
 
+from databricks.sdk.service._internal import (Wait, _enum, _from_dict,
+                                              _repeated_dict, _repeated_enum)
+
 from ..errors import OperationFailed
-from ._internal import Wait, _enum, _from_dict, _repeated_dict, _repeated_enum
 
 _LOG = logging.getLogger("databricks.sdk")
 
@@ -63,8 +65,191 @@ class AccessRequestDestinations:
         )
 
 
+@dataclass
+class AccountsCreateMetastoreAssignmentResponse:
+    """The metastore assignment was successfully created."""
+
+    def as_dict(self) -> dict:
+        """Serializes the AccountsCreateMetastoreAssignmentResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AccountsCreateMetastoreAssignmentResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> AccountsCreateMetastoreAssignmentResponse:
+        """Deserializes the AccountsCreateMetastoreAssignmentResponse from a dictionary."""
+        return cls()
+
+
+@dataclass
+class AccountsCreateMetastoreResponse:
+    metastore_info: Optional[MetastoreInfo] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the AccountsCreateMetastoreResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.metastore_info:
+            body["metastore_info"] = self.metastore_info.as_dict()
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AccountsCreateMetastoreResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.metastore_info:
+            body["metastore_info"] = self.metastore_info
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> AccountsCreateMetastoreResponse:
+        """Deserializes the AccountsCreateMetastoreResponse from a dictionary."""
+        return cls(metastore_info=_from_dict(d, "metastore_info", MetastoreInfo))
+
+
+@dataclass
+class AccountsCreateStorageCredentialInfo:
+    credential_info: Optional[StorageCredentialInfo] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the AccountsCreateStorageCredentialInfo into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.credential_info:
+            body["credential_info"] = self.credential_info.as_dict()
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AccountsCreateStorageCredentialInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.credential_info:
+            body["credential_info"] = self.credential_info
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> AccountsCreateStorageCredentialInfo:
+        """Deserializes the AccountsCreateStorageCredentialInfo from a dictionary."""
+        return cls(credential_info=_from_dict(d, "credential_info", StorageCredentialInfo))
+
+
+@dataclass
+class AccountsDeleteMetastoreAssignmentResponse:
+    """The metastore assignment was successfully deleted."""
+
+    def as_dict(self) -> dict:
+        """Serializes the AccountsDeleteMetastoreAssignmentResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AccountsDeleteMetastoreAssignmentResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> AccountsDeleteMetastoreAssignmentResponse:
+        """Deserializes the AccountsDeleteMetastoreAssignmentResponse from a dictionary."""
+        return cls()
+
+
+@dataclass
+class AccountsDeleteMetastoreResponse:
+    """The metastore was successfully deleted."""
+
+    def as_dict(self) -> dict:
+        """Serializes the AccountsDeleteMetastoreResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AccountsDeleteMetastoreResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> AccountsDeleteMetastoreResponse:
+        """Deserializes the AccountsDeleteMetastoreResponse from a dictionary."""
+        return cls()
+
+
+@dataclass
+class AccountsDeleteStorageCredentialResponse:
+    """The storage credential was successfully deleted."""
+
+    def as_dict(self) -> dict:
+        """Serializes the AccountsDeleteStorageCredentialResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AccountsDeleteStorageCredentialResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> AccountsDeleteStorageCredentialResponse:
+        """Deserializes the AccountsDeleteStorageCredentialResponse from a dictionary."""
+        return cls()
+
+
+@dataclass
+class AccountsGetMetastoreResponse:
+    """The metastore was successfully returned."""
+
+    metastore_info: Optional[MetastoreInfo] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the AccountsGetMetastoreResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.metastore_info:
+            body["metastore_info"] = self.metastore_info.as_dict()
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AccountsGetMetastoreResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.metastore_info:
+            body["metastore_info"] = self.metastore_info
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> AccountsGetMetastoreResponse:
+        """Deserializes the AccountsGetMetastoreResponse from a dictionary."""
+        return cls(metastore_info=_from_dict(d, "metastore_info", MetastoreInfo))
+
+
+@dataclass
+class AccountsListMetastoresResponse:
+    """Metastores were returned successfully."""
+
+    metastores: Optional[List[MetastoreInfo]] = None
+    """An array of metastore information objects."""
+
+    def as_dict(self) -> dict:
+        """Serializes the AccountsListMetastoresResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.metastores:
+            body["metastores"] = [v.as_dict() for v in self.metastores]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AccountsListMetastoresResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.metastores:
+            body["metastores"] = self.metastores
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> AccountsListMetastoresResponse:
+        """Deserializes the AccountsListMetastoresResponse from a dictionary."""
+        return cls(metastores=_repeated_dict(d, "metastores", MetastoreInfo))
+
+
 @dataclass
 class AccountsMetastoreAssignment:
+    """The workspace metastore assignment was successfully returned."""
+
     metastore_assignment: Optional[MetastoreAssignment] = None
 
     def as_dict(self) -> dict:
@@ -88,50 +273,100 @@ class AccountsMetastoreAssignment:
 
 
 @dataclass
-class AccountsMetastoreInfo:
+class AccountsStorageCredentialInfo:
+    """The storage credential was successfully retrieved."""
+
+    credential_info: Optional[StorageCredentialInfo] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the AccountsStorageCredentialInfo into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.credential_info:
+            body["credential_info"] = self.credential_info.as_dict()
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AccountsStorageCredentialInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.credential_info:
+            body["credential_info"] = self.credential_info
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> AccountsStorageCredentialInfo:
+        """Deserializes the AccountsStorageCredentialInfo from a dictionary."""
+        return cls(credential_info=_from_dict(d, "credential_info", StorageCredentialInfo))
+
+
+@dataclass
+class AccountsUpdateMetastoreAssignmentResponse:
+    """The metastore assignment was successfully updated."""
+
+    def as_dict(self) -> dict:
+        """Serializes the AccountsUpdateMetastoreAssignmentResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AccountsUpdateMetastoreAssignmentResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> AccountsUpdateMetastoreAssignmentResponse:
+        """Deserializes the AccountsUpdateMetastoreAssignmentResponse from a dictionary."""
+        return cls()
+
+
+@dataclass
+class AccountsUpdateMetastoreResponse:
+    """The metastore update request succeeded."""
+
     metastore_info: Optional[MetastoreInfo] = None
 
     def as_dict(self) -> dict:
-        """Serializes the AccountsMetastoreInfo into a dictionary suitable for use as a JSON request body."""
+        """Serializes the AccountsUpdateMetastoreResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.metastore_info:
             body["metastore_info"] = self.metastore_info.as_dict()
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the AccountsMetastoreInfo into a shallow dictionary of its immediate attributes."""
+        """Serializes the AccountsUpdateMetastoreResponse into a shallow dictionary of its immediate attributes."""
         body = {}
         if self.metastore_info:
             body["metastore_info"] = self.metastore_info
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> AccountsMetastoreInfo:
-        """Deserializes the AccountsMetastoreInfo from a dictionary."""
+    def from_dict(cls, d: Dict[str, Any]) -> AccountsUpdateMetastoreResponse:
+        """Deserializes the AccountsUpdateMetastoreResponse from a dictionary."""
         return cls(metastore_info=_from_dict(d, "metastore_info", MetastoreInfo))
 
 
 @dataclass
-class AccountsStorageCredentialInfo:
+class AccountsUpdateStorageCredentialResponse:
+    """The storage credential was successfully updated."""
+
     credential_info: Optional[StorageCredentialInfo] = None
 
     def as_dict(self) -> dict:
-        """Serializes the AccountsStorageCredentialInfo into a dictionary suitable for use as a JSON request body."""
+        """Serializes the AccountsUpdateStorageCredentialResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.credential_info:
             body["credential_info"] = self.credential_info.as_dict()
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the AccountsStorageCredentialInfo into a shallow dictionary of its immediate attributes."""
+        """Serializes the AccountsUpdateStorageCredentialResponse into a shallow dictionary of its immediate attributes."""
         body = {}
         if self.credential_info:
             body["credential_info"] = self.credential_info
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> AccountsStorageCredentialInfo:
-        """Deserializes the AccountsStorageCredentialInfo from a dictionary."""
+    def from_dict(cls, d: Dict[str, Any]) -> AccountsUpdateStorageCredentialResponse:
+        """Deserializes the AccountsUpdateStorageCredentialResponse from a dictionary."""
         return cls(credential_info=_from_dict(d, "credential_info", StorageCredentialInfo))
 
 
@@ -1666,58 +1901,185 @@ class CreateAccessRequestResponse:
 
 
 @dataclass
-class CreateFunction:
+class CreateAccountsMetastore:
     name: str
-    """Name of function, relative to parent schema."""
-
-    catalog_name: str
-    """Name of parent catalog."""
-
-    schema_name: str
-    """Name of parent schema relative to its parent catalog."""
+    """The user-specified name of the metastore."""
 
-    input_params: FunctionParameterInfos
+    region: Optional[str] = None
+    """Cloud region which the metastore serves (e.g., `us-west-2`, `westus`)."""
 
-    data_type: ColumnTypeName
-    """Scalar function return data type."""
+    storage_root: Optional[str] = None
+    """The storage root URL for metastore"""
 
-    full_data_type: str
-    """Pretty printed function data type."""
+    def as_dict(self) -> dict:
+        """Serializes the CreateAccountsMetastore into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.name is not None:
+            body["name"] = self.name
+        if self.region is not None:
+            body["region"] = self.region
+        if self.storage_root is not None:
+            body["storage_root"] = self.storage_root
+        return body
 
-    routine_body: CreateFunctionRoutineBody
-    """Function language. When **EXTERNAL** is used, the language of the routine function should be
-    specified in the __external_language__ field, and the __return_params__ of the function cannot
-    be used (as **TABLE** return type is not supported), and the __sql_data_access__ field must be
-    **NO_SQL**."""
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateAccountsMetastore into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.name is not None:
+            body["name"] = self.name
+        if self.region is not None:
+            body["region"] = self.region
+        if self.storage_root is not None:
+            body["storage_root"] = self.storage_root
+        return body
 
-    routine_definition: str
-    """Function body."""
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> CreateAccountsMetastore:
+        """Deserializes the CreateAccountsMetastore from a dictionary."""
+        return cls(name=d.get("name", None), region=d.get("region", None), storage_root=d.get("storage_root", None))
 
-    parameter_style: CreateFunctionParameterStyle
-    """Function parameter style. **S** is the value for SQL."""
 
-    is_deterministic: bool
-    """Whether the function is deterministic."""
+@dataclass
+class CreateAccountsStorageCredential:
+    name: str
+    """The credential name. The name must be unique among storage and service credentials within the
+    metastore."""
 
-    sql_data_access: CreateFunctionSqlDataAccess
-    """Function SQL data access."""
+    aws_iam_role: Optional[AwsIamRoleRequest] = None
+    """The AWS IAM role configuration."""
 
-    is_null_call: bool
-    """Function null call."""
+    azure_managed_identity: Optional[AzureManagedIdentityRequest] = None
+    """The Azure managed identity configuration."""
 
-    security_type: CreateFunctionSecurityType
-    """Function security type."""
+    azure_service_principal: Optional[AzureServicePrincipal] = None
+    """The Azure service principal configuration."""
 
-    specific_name: str
-    """Specific name of the function; Reserved for future use."""
+    cloudflare_api_token: Optional[CloudflareApiToken] = None
+    """The Cloudflare API token configuration."""
 
     comment: Optional[str] = None
-    """User-provided free-form text description."""
+    """Comment associated with the credential."""
 
-    external_language: Optional[str] = None
-    """External function language."""
+    databricks_gcp_service_account: Optional[DatabricksGcpServiceAccountRequest] = None
+    """The Databricks managed GCP service account configuration."""
 
-    external_name: Optional[str] = None
+    read_only: Optional[bool] = None
+    """Whether the credential is usable only for read operations. Only applicable when purpose is
+    **STORAGE**."""
+
+    def as_dict(self) -> dict:
+        """Serializes the CreateAccountsStorageCredential into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.aws_iam_role:
+            body["aws_iam_role"] = self.aws_iam_role.as_dict()
+        if self.azure_managed_identity:
+            body["azure_managed_identity"] = self.azure_managed_identity.as_dict()
+        if self.azure_service_principal:
+            body["azure_service_principal"] = self.azure_service_principal.as_dict()
+        if self.cloudflare_api_token:
+            body["cloudflare_api_token"] = self.cloudflare_api_token.as_dict()
+        if self.comment is not None:
+            body["comment"] = self.comment
+        if self.databricks_gcp_service_account:
+            body["databricks_gcp_service_account"] = self.databricks_gcp_service_account.as_dict()
+        if self.name is not None:
+            body["name"] = self.name
+        if self.read_only is not None:
+            body["read_only"] = self.read_only
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateAccountsStorageCredential into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.aws_iam_role:
+            body["aws_iam_role"] = self.aws_iam_role
+        if self.azure_managed_identity:
+            body["azure_managed_identity"] = self.azure_managed_identity
+        if self.azure_service_principal:
+            body["azure_service_principal"] = self.azure_service_principal
+        if self.cloudflare_api_token:
+            body["cloudflare_api_token"] = self.cloudflare_api_token
+        if self.comment is not None:
+            body["comment"] = self.comment
+        if self.databricks_gcp_service_account:
+            body["databricks_gcp_service_account"] = self.databricks_gcp_service_account
+        if self.name is not None:
+            body["name"] = self.name
+        if self.read_only is not None:
+            body["read_only"] = self.read_only
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> CreateAccountsStorageCredential:
+        """Deserializes the CreateAccountsStorageCredential from a dictionary."""
+        return cls(
+            aws_iam_role=_from_dict(d, "aws_iam_role", AwsIamRoleRequest),
+            azure_managed_identity=_from_dict(d, "azure_managed_identity", AzureManagedIdentityRequest),
+            azure_service_principal=_from_dict(d, "azure_service_principal", AzureServicePrincipal),
+            cloudflare_api_token=_from_dict(d, "cloudflare_api_token", CloudflareApiToken),
+            comment=d.get("comment", None),
+            databricks_gcp_service_account=_from_dict(
+                d, "databricks_gcp_service_account", DatabricksGcpServiceAccountRequest
+            ),
+            name=d.get("name", None),
+            read_only=d.get("read_only", None),
+        )
+
+
+@dataclass
+class CreateFunction:
+    name: str
+    """Name of function, relative to parent schema."""
+
+    catalog_name: str
+    """Name of parent Catalog."""
+
+    schema_name: str
+    """Name of parent Schema relative to its parent Catalog."""
+
+    input_params: FunctionParameterInfos
+    """Function input parameters."""
+
+    data_type: ColumnTypeName
+    """Scalar function return data type."""
+
+    full_data_type: str
+    """Pretty printed function data type."""
+
+    routine_body: CreateFunctionRoutineBody
+    """Function language. When **EXTERNAL** is used, the language of the routine function should be
+    specified in the **external_language** field, and the **return_params** of the function cannot
+    be used (as **TABLE** return type is not supported), and the **sql_data_access** field must be
+    **NO_SQL**."""
+
+    routine_definition: str
+    """Function body."""
+
+    parameter_style: CreateFunctionParameterStyle
+    """Function parameter style. **S** is the value for SQL."""
+
+    is_deterministic: bool
+    """Whether the function is deterministic."""
+
+    sql_data_access: CreateFunctionSqlDataAccess
+    """Function SQL data access."""
+
+    is_null_call: bool
+    """Function null call."""
+
+    security_type: CreateFunctionSecurityType
+    """Function security type."""
+
+    specific_name: str
+    """Specific name of the function; Reserved for future use."""
+
+    comment: Optional[str] = None
+    """User-provided free-form text description."""
+
+    external_language: Optional[str] = None
+    """External function language."""
+
+    external_name: Optional[str] = None
     """External function name."""
 
     properties: Optional[str] = None
@@ -1727,7 +2089,7 @@ class CreateFunction:
     """Table function return parameters."""
 
     routine_dependencies: Optional[DependencyList] = None
-    """Function dependencies."""
+    """function dependencies."""
 
     sql_path: Optional[str] = None
     """List of schemes whose objects can be referenced without qualification."""
@@ -1855,74 +2217,28 @@ class CreateFunction:
 
 
 class CreateFunctionParameterStyle(Enum):
-    """Function parameter style. **S** is the value for SQL."""
 
     S = "S"
 
 
 class CreateFunctionRoutineBody(Enum):
-    """Function language. When **EXTERNAL** is used, the language of the routine function should be
-    specified in the __external_language__ field, and the __return_params__ of the function cannot
-    be used (as **TABLE** return type is not supported), and the __sql_data_access__ field must be
-    **NO_SQL**."""
 
     EXTERNAL = "EXTERNAL"
     SQL = "SQL"
 
 
 class CreateFunctionSecurityType(Enum):
-    """The security type of the function."""
 
     DEFINER = "DEFINER"
 
 
 class CreateFunctionSqlDataAccess(Enum):
-    """Function SQL data access."""
 
     CONTAINS_SQL = "CONTAINS_SQL"
     NO_SQL = "NO_SQL"
     READS_SQL_DATA = "READS_SQL_DATA"
 
 
-@dataclass
-class CreateMetastore:
-    name: str
-    """The user-specified name of the metastore."""
-
-    region: Optional[str] = None
-    """Cloud region which the metastore serves (e.g., `us-west-2`, `westus`)."""
-
-    storage_root: Optional[str] = None
-    """The storage root URL for metastore"""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateMetastore into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.name is not None:
-            body["name"] = self.name
-        if self.region is not None:
-            body["region"] = self.region
-        if self.storage_root is not None:
-            body["storage_root"] = self.storage_root
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateMetastore into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.name is not None:
-            body["name"] = self.name
-        if self.region is not None:
-            body["region"] = self.region
-        if self.storage_root is not None:
-            body["storage_root"] = self.storage_root
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateMetastore:
-        """Deserializes the CreateMetastore from a dictionary."""
-        return cls(name=d.get("name", None), region=d.get("region", None), storage_root=d.get("storage_root", None))
-
-
 @dataclass
 class CreateMetastoreAssignment:
     metastore_id: str
@@ -2026,119 +2342,6 @@ class CreateRequestExternalLineage:
         )
 
 
-@dataclass
-class CreateResponse:
-    def as_dict(self) -> dict:
-        """Serializes the CreateResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateResponse:
-        """Deserializes the CreateResponse from a dictionary."""
-        return cls()
-
-
-@dataclass
-class CreateStorageCredential:
-    name: str
-    """The credential name. The name must be unique among storage and service credentials within the
-    metastore."""
-
-    aws_iam_role: Optional[AwsIamRoleRequest] = None
-    """The AWS IAM role configuration."""
-
-    azure_managed_identity: Optional[AzureManagedIdentityRequest] = None
-    """The Azure managed identity configuration."""
-
-    azure_service_principal: Optional[AzureServicePrincipal] = None
-    """The Azure service principal configuration."""
-
-    cloudflare_api_token: Optional[CloudflareApiToken] = None
-    """The Cloudflare API token configuration."""
-
-    comment: Optional[str] = None
-    """Comment associated with the credential."""
-
-    databricks_gcp_service_account: Optional[DatabricksGcpServiceAccountRequest] = None
-    """The Databricks managed GCP service account configuration."""
-
-    read_only: Optional[bool] = None
-    """Whether the credential is usable only for read operations. Only applicable when purpose is
-    **STORAGE**."""
-
-    skip_validation: Optional[bool] = None
-    """Supplying true to this argument skips validation of the created credential."""
-
-    def as_dict(self) -> dict:
-        """Serializes the CreateStorageCredential into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.aws_iam_role:
-            body["aws_iam_role"] = self.aws_iam_role.as_dict()
-        if self.azure_managed_identity:
-            body["azure_managed_identity"] = self.azure_managed_identity.as_dict()
-        if self.azure_service_principal:
-            body["azure_service_principal"] = self.azure_service_principal.as_dict()
-        if self.cloudflare_api_token:
-            body["cloudflare_api_token"] = self.cloudflare_api_token.as_dict()
-        if self.comment is not None:
-            body["comment"] = self.comment
-        if self.databricks_gcp_service_account:
-            body["databricks_gcp_service_account"] = self.databricks_gcp_service_account.as_dict()
-        if self.name is not None:
-            body["name"] = self.name
-        if self.read_only is not None:
-            body["read_only"] = self.read_only
-        if self.skip_validation is not None:
-            body["skip_validation"] = self.skip_validation
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the CreateStorageCredential into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.aws_iam_role:
-            body["aws_iam_role"] = self.aws_iam_role
-        if self.azure_managed_identity:
-            body["azure_managed_identity"] = self.azure_managed_identity
-        if self.azure_service_principal:
-            body["azure_service_principal"] = self.azure_service_principal
-        if self.cloudflare_api_token:
-            body["cloudflare_api_token"] = self.cloudflare_api_token
-        if self.comment is not None:
-            body["comment"] = self.comment
-        if self.databricks_gcp_service_account:
-            body["databricks_gcp_service_account"] = self.databricks_gcp_service_account
-        if self.name is not None:
-            body["name"] = self.name
-        if self.read_only is not None:
-            body["read_only"] = self.read_only
-        if self.skip_validation is not None:
-            body["skip_validation"] = self.skip_validation
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> CreateStorageCredential:
-        """Deserializes the CreateStorageCredential from a dictionary."""
-        return cls(
-            aws_iam_role=_from_dict(d, "aws_iam_role", AwsIamRoleRequest),
-            azure_managed_identity=_from_dict(d, "azure_managed_identity", AzureManagedIdentityRequest),
-            azure_service_principal=_from_dict(d, "azure_service_principal", AzureServicePrincipal),
-            cloudflare_api_token=_from_dict(d, "cloudflare_api_token", CloudflareApiToken),
-            comment=d.get("comment", None),
-            databricks_gcp_service_account=_from_dict(
-                d, "databricks_gcp_service_account", DatabricksGcpServiceAccountRequest
-            ),
-            name=d.get("name", None),
-            read_only=d.get("read_only", None),
-            skip_validation=d.get("skip_validation", None),
-        )
-
-
 @dataclass
 class CredentialDependency:
     """A credential that is dependent on a SQL object."""
@@ -4143,7 +4346,7 @@ class FunctionInfo:
     through the BROWSE privilege when include_browse is enabled in the request."""
 
     catalog_name: Optional[str] = None
-    """Name of parent catalog."""
+    """Name of parent Catalog."""
 
     comment: Optional[str] = None
     """User-provided free-form text description."""
@@ -4167,12 +4370,13 @@ class FunctionInfo:
     """Pretty printed function data type."""
 
     full_name: Optional[str] = None
-    """Full name of function, in form of __catalog_name__.__schema_name__.__function__name__"""
+    """Full name of Function, in form of **catalog_name**.**schema_name**.**function_name**"""
 
     function_id: Optional[str] = None
     """Id of Function, relative to parent schema."""
 
     input_params: Optional[FunctionParameterInfos] = None
+    """Function input parameters."""
 
     is_deterministic: Optional[bool] = None
     """Whether the function is deterministic."""
@@ -4187,7 +4391,7 @@ class FunctionInfo:
     """Name of function, relative to parent schema."""
 
     owner: Optional[str] = None
-    """Username of current owner of function."""
+    """Username of current owner of the function."""
 
     parameter_style: Optional[FunctionInfoParameterStyle] = None
     """Function parameter style. **S** is the value for SQL."""
@@ -4200,18 +4404,18 @@ class FunctionInfo:
 
     routine_body: Optional[FunctionInfoRoutineBody] = None
     """Function language. When **EXTERNAL** is used, the language of the routine function should be
-    specified in the __external_language__ field, and the __return_params__ of the function cannot
-    be used (as **TABLE** return type is not supported), and the __sql_data_access__ field must be
+    specified in the **external_language** field, and the **return_params** of the function cannot
+    be used (as **TABLE** return type is not supported), and the **sql_data_access** field must be
     **NO_SQL**."""
 
     routine_definition: Optional[str] = None
     """Function body."""
 
     routine_dependencies: Optional[DependencyList] = None
-    """Function dependencies."""
+    """function dependencies."""
 
     schema_name: Optional[str] = None
-    """Name of parent schema relative to its parent catalog."""
+    """Name of parent Schema relative to its parent Catalog."""
 
     security_type: Optional[FunctionInfoSecurityType] = None
     """Function security type."""
@@ -4226,10 +4430,10 @@ class FunctionInfo:
     """List of schemes whose objects can be referenced without qualification."""
 
     updated_at: Optional[int] = None
-    """Time at which this function was created, in epoch milliseconds."""
+    """Time at which this function was last modified, in epoch milliseconds."""
 
     updated_by: Optional[str] = None
-    """Username of user who last modified function."""
+    """Username of user who last modified the function."""
 
     def as_dict(self) -> dict:
         """Serializes the FunctionInfo into a dictionary suitable for use as a JSON request body."""
@@ -4399,29 +4603,22 @@ class FunctionInfo:
 
 
 class FunctionInfoParameterStyle(Enum):
-    """Function parameter style. **S** is the value for SQL."""
 
     S = "S"
 
 
 class FunctionInfoRoutineBody(Enum):
-    """Function language. When **EXTERNAL** is used, the language of the routine function should be
-    specified in the __external_language__ field, and the __return_params__ of the function cannot
-    be used (as **TABLE** return type is not supported), and the __sql_data_access__ field must be
-    **NO_SQL**."""
 
     EXTERNAL = "EXTERNAL"
     SQL = "SQL"
 
 
 class FunctionInfoSecurityType(Enum):
-    """The security type of the function."""
 
     DEFINER = "DEFINER"
 
 
 class FunctionInfoSqlDataAccess(Enum):
-    """Function SQL data access."""
 
     CONTAINS_SQL = "CONTAINS_SQL"
     NO_SQL = "NO_SQL"
@@ -4431,12 +4628,13 @@ class FunctionInfoSqlDataAccess(Enum):
 @dataclass
 class FunctionParameterInfo:
     name: str
-    """Name of parameter."""
+    """Name of Parameter."""
 
     type_text: str
     """Full data type spec, SQL/catalogString text."""
 
     type_name: ColumnTypeName
+    """Name of type (INT, STRUCT, MAP, etc.)"""
 
     position: int
     """Ordinal position of column (starting at position 0)."""
@@ -4448,8 +4646,10 @@ class FunctionParameterInfo:
     """Default value of the parameter."""
 
     parameter_mode: Optional[FunctionParameterMode] = None
+    """Function parameter mode."""
 
     parameter_type: Optional[FunctionParameterType] = None
+    """Function parameter type."""
 
     type_interval_type: Optional[str] = None
     """Format of IntervalType."""
@@ -4543,7 +4743,6 @@ class FunctionParameterInfo:
 @dataclass
 class FunctionParameterInfos:
     parameters: Optional[List[FunctionParameterInfo]] = None
-    """The array of __FunctionParameterInfo__ definitions of the function's parameters."""
 
     def as_dict(self) -> dict:
         """Serializes the FunctionParameterInfos into a dictionary suitable for use as a JSON request body."""
@@ -4566,13 +4765,11 @@ class FunctionParameterInfos:
 
 
 class FunctionParameterMode(Enum):
-    """The mode of the function parameter."""
 
     IN = "IN"
 
 
 class FunctionParameterType(Enum):
-    """The type of function parameter."""
 
     COLUMN = "COLUMN"
     PARAM = "PARAM"
@@ -5153,7 +5350,7 @@ class LineageDirection(Enum):
 
 @dataclass
 class ListAccountMetastoreAssignmentsResponse:
-    """The list of workspaces to which the given metastore is assigned."""
+    """The metastore assignments were successfully returned."""
 
     workspace_ids: Optional[List[int]] = None
 
@@ -5179,6 +5376,8 @@ class ListAccountMetastoreAssignmentsResponse:
 
 @dataclass
 class ListAccountStorageCredentialsResponse:
+    """The metastore storage credentials were successfully returned."""
+
     storage_credentials: Optional[List[StorageCredentialInfo]] = None
     """An array of metastore storage credentials."""
 
@@ -5896,7 +6095,8 @@ class MetastoreAssignment:
     """The unique ID of the metastore."""
 
     default_catalog_name: Optional[str] = None
-    """The name of the default catalog in the metastore."""
+    """The name of the default catalog in the metastore. This field is deprecated. Please use "Default
+    Namespace API" to configure the default catalog for a Databricks workspace."""
 
     def as_dict(self) -> dict:
         """Serializes the MetastoreAssignment into a dictionary suitable for use as a JSON request body."""
@@ -6113,10 +6313,6 @@ class ModelVersionInfo:
     aliases: Optional[List[RegisteredModelAlias]] = None
     """List of aliases associated with the model version"""
 
-    browse_only: Optional[bool] = None
-    """Indicates whether the principal is limited to retrieving metadata for the associated object
-    through the BROWSE privilege when include_browse is enabled in the request."""
-
     catalog_name: Optional[str] = None
     """The name of the catalog containing the model version"""
 
@@ -6175,8 +6371,6 @@ class ModelVersionInfo:
         body = {}
         if self.aliases:
             body["aliases"] = [v.as_dict() for v in self.aliases]
-        if self.browse_only is not None:
-            body["browse_only"] = self.browse_only
         if self.catalog_name is not None:
             body["catalog_name"] = self.catalog_name
         if self.comment is not None:
@@ -6218,8 +6412,6 @@ class ModelVersionInfo:
         body = {}
         if self.aliases:
             body["aliases"] = self.aliases
-        if self.browse_only is not None:
-            body["browse_only"] = self.browse_only
         if self.catalog_name is not None:
             body["catalog_name"] = self.catalog_name
         if self.comment is not None:
@@ -6261,7 +6453,6 @@ class ModelVersionInfo:
         """Deserializes the ModelVersionInfo from a dictionary."""
         return cls(
             aliases=_repeated_dict(d, "aliases", RegisteredModelAlias),
-            browse_only=d.get("browse_only", None),
             catalog_name=d.get("catalog_name", None),
             comment=d.get("comment", None),
             created_at=d.get("created_at", None),
@@ -6283,11 +6474,9 @@ class ModelVersionInfo:
 
 
 class ModelVersionInfoStatus(Enum):
-    """Current status of the model version. Newly created model versions start in PENDING_REGISTRATION
-    status, then move to READY status once the model version files are uploaded and the model
-    version is finalized. Only model versions in READY status can be loaded for inference or served."""
 
     FAILED_REGISTRATION = "FAILED_REGISTRATION"
+    MODEL_VERSION_STATUS_UNKNOWN = "MODEL_VERSION_STATUS_UNKNOWN"
     PENDING_REGISTRATION = "PENDING_REGISTRATION"
     READY = "READY"
 
@@ -8125,11 +8314,21 @@ class RegenerateDashboardResponse:
 
 @dataclass
 class RegisteredModelAlias:
-    """Registered model alias."""
-
     alias_name: Optional[str] = None
     """Name of the alias, e.g. 'champion' or 'latest_stable'"""
 
+    catalog_name: Optional[str] = None
+    """The name of the catalog containing the model version"""
+
+    id: Optional[str] = None
+    """The unique identifier of the alias"""
+
+    model_name: Optional[str] = None
+    """The name of the parent registered model of the model version, relative to parent schema"""
+
+    schema_name: Optional[str] = None
+    """The name of the schema containing the model version, relative to parent catalog"""
+
     version_num: Optional[int] = None
     """Integer version number of the model version to which this alias points."""
 
@@ -8138,6 +8337,14 @@ class RegisteredModelAlias:
         body = {}
         if self.alias_name is not None:
             body["alias_name"] = self.alias_name
+        if self.catalog_name is not None:
+            body["catalog_name"] = self.catalog_name
+        if self.id is not None:
+            body["id"] = self.id
+        if self.model_name is not None:
+            body["model_name"] = self.model_name
+        if self.schema_name is not None:
+            body["schema_name"] = self.schema_name
         if self.version_num is not None:
             body["version_num"] = self.version_num
         return body
@@ -8147,6 +8354,14 @@ class RegisteredModelAlias:
         body = {}
         if self.alias_name is not None:
             body["alias_name"] = self.alias_name
+        if self.catalog_name is not None:
+            body["catalog_name"] = self.catalog_name
+        if self.id is not None:
+            body["id"] = self.id
+        if self.model_name is not None:
+            body["model_name"] = self.model_name
+        if self.schema_name is not None:
+            body["schema_name"] = self.schema_name
         if self.version_num is not None:
             body["version_num"] = self.version_num
         return body
@@ -8154,7 +8369,14 @@ class RegisteredModelAlias:
     @classmethod
     def from_dict(cls, d: Dict[str, Any]) -> RegisteredModelAlias:
         """Deserializes the RegisteredModelAlias from a dictionary."""
-        return cls(alias_name=d.get("alias_name", None), version_num=d.get("version_num", None))
+        return cls(
+            alias_name=d.get("alias_name", None),
+            catalog_name=d.get("catalog_name", None),
+            id=d.get("id", None),
+            model_name=d.get("model_name", None),
+            schema_name=d.get("schema_name", None),
+            version_num=d.get("version_num", None),
+        )
 
 
 @dataclass
@@ -8540,7 +8762,7 @@ class Securable:
 
 
 class SecurableKind(Enum):
-    """Latest kind: CONNECTION_SHAREPOINT_OAUTH_M2M = 264; Next id:265"""
+    """Latest kind: CONNECTION_REDSHIFT_IAM = 265; Next id:266"""
 
     TABLE_DB_STORAGE = "TABLE_DB_STORAGE"
     TABLE_DELTA = "TABLE_DELTA"
@@ -9636,50 +9858,7 @@ class UnassignResponse:
 
 
 @dataclass
-class UpdateAssignmentResponse:
-    def as_dict(self) -> dict:
-        """Serializes the UpdateAssignmentResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateAssignmentResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> UpdateAssignmentResponse:
-        """Deserializes the UpdateAssignmentResponse from a dictionary."""
-        return cls()
-
-
-@dataclass
-class UpdateCatalogWorkspaceBindingsResponse:
-    workspaces: Optional[List[int]] = None
-    """A list of workspace IDs"""
-
-    def as_dict(self) -> dict:
-        """Serializes the UpdateCatalogWorkspaceBindingsResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        if self.workspaces:
-            body["workspaces"] = [v for v in self.workspaces]
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateCatalogWorkspaceBindingsResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.workspaces:
-            body["workspaces"] = self.workspaces
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> UpdateCatalogWorkspaceBindingsResponse:
-        """Deserializes the UpdateCatalogWorkspaceBindingsResponse from a dictionary."""
-        return cls(workspaces=d.get("workspaces", None))
-
-
-@dataclass
-class UpdateMetastore:
+class UpdateAccountsMetastore:
     delta_sharing_organization_name: Optional[str] = None
     """The organization name of a Delta Sharing entity, to be used in Databricks-to-Databricks Delta
     Sharing as the official name."""
@@ -9690,12 +9869,6 @@ class UpdateMetastore:
     delta_sharing_scope: Optional[DeltaSharingScopeEnum] = None
     """The scope of Delta Sharing enabled for the metastore."""
 
-    id: Optional[str] = None
-    """Unique ID of the metastore."""
-
-    new_name: Optional[str] = None
-    """New name for the metastore."""
-
     owner: Optional[str] = None
     """The owner of the metastore."""
 
@@ -9706,7 +9879,7 @@ class UpdateMetastore:
     """UUID of storage credential to access the metastore storage_root."""
 
     def as_dict(self) -> dict:
-        """Serializes the UpdateMetastore into a dictionary suitable for use as a JSON request body."""
+        """Serializes the UpdateAccountsMetastore into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.delta_sharing_organization_name is not None:
             body["delta_sharing_organization_name"] = self.delta_sharing_organization_name
@@ -9716,10 +9889,6 @@ class UpdateMetastore:
             )
         if self.delta_sharing_scope is not None:
             body["delta_sharing_scope"] = self.delta_sharing_scope.value
-        if self.id is not None:
-            body["id"] = self.id
-        if self.new_name is not None:
-            body["new_name"] = self.new_name
         if self.owner is not None:
             body["owner"] = self.owner
         if self.privilege_model_version is not None:
@@ -9729,7 +9898,7 @@ class UpdateMetastore:
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateMetastore into a shallow dictionary of its immediate attributes."""
+        """Serializes the UpdateAccountsMetastore into a shallow dictionary of its immediate attributes."""
         body = {}
         if self.delta_sharing_organization_name is not None:
             body["delta_sharing_organization_name"] = self.delta_sharing_organization_name
@@ -9739,10 +9908,6 @@ class UpdateMetastore:
             )
         if self.delta_sharing_scope is not None:
             body["delta_sharing_scope"] = self.delta_sharing_scope
-        if self.id is not None:
-            body["id"] = self.id
-        if self.new_name is not None:
-            body["new_name"] = self.new_name
         if self.owner is not None:
             body["owner"] = self.owner
         if self.privilege_model_version is not None:
@@ -9752,22 +9917,157 @@ class UpdateMetastore:
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> UpdateMetastore:
-        """Deserializes the UpdateMetastore from a dictionary."""
+    def from_dict(cls, d: Dict[str, Any]) -> UpdateAccountsMetastore:
+        """Deserializes the UpdateAccountsMetastore from a dictionary."""
         return cls(
             delta_sharing_organization_name=d.get("delta_sharing_organization_name", None),
             delta_sharing_recipient_token_lifetime_in_seconds=d.get(
                 "delta_sharing_recipient_token_lifetime_in_seconds", None
             ),
             delta_sharing_scope=_enum(d, "delta_sharing_scope", DeltaSharingScopeEnum),
-            id=d.get("id", None),
-            new_name=d.get("new_name", None),
             owner=d.get("owner", None),
             privilege_model_version=d.get("privilege_model_version", None),
             storage_root_credential_id=d.get("storage_root_credential_id", None),
         )
 
 
+@dataclass
+class UpdateAccountsStorageCredential:
+    aws_iam_role: Optional[AwsIamRoleRequest] = None
+    """The AWS IAM role configuration."""
+
+    azure_managed_identity: Optional[AzureManagedIdentityResponse] = None
+    """The Azure managed identity configuration."""
+
+    azure_service_principal: Optional[AzureServicePrincipal] = None
+    """The Azure service principal configuration."""
+
+    cloudflare_api_token: Optional[CloudflareApiToken] = None
+    """The Cloudflare API token configuration."""
+
+    comment: Optional[str] = None
+    """Comment associated with the credential."""
+
+    databricks_gcp_service_account: Optional[DatabricksGcpServiceAccountRequest] = None
+    """The Databricks managed GCP service account configuration."""
+
+    isolation_mode: Optional[IsolationMode] = None
+    """Whether the current securable is accessible from all workspaces or a specific set of workspaces."""
+
+    owner: Optional[str] = None
+    """Username of current owner of credential."""
+
+    read_only: Optional[bool] = None
+    """Whether the credential is usable only for read operations. Only applicable when purpose is
+    **STORAGE**."""
+
+    def as_dict(self) -> dict:
+        """Serializes the UpdateAccountsStorageCredential into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.aws_iam_role:
+            body["aws_iam_role"] = self.aws_iam_role.as_dict()
+        if self.azure_managed_identity:
+            body["azure_managed_identity"] = self.azure_managed_identity.as_dict()
+        if self.azure_service_principal:
+            body["azure_service_principal"] = self.azure_service_principal.as_dict()
+        if self.cloudflare_api_token:
+            body["cloudflare_api_token"] = self.cloudflare_api_token.as_dict()
+        if self.comment is not None:
+            body["comment"] = self.comment
+        if self.databricks_gcp_service_account:
+            body["databricks_gcp_service_account"] = self.databricks_gcp_service_account.as_dict()
+        if self.isolation_mode is not None:
+            body["isolation_mode"] = self.isolation_mode.value
+        if self.owner is not None:
+            body["owner"] = self.owner
+        if self.read_only is not None:
+            body["read_only"] = self.read_only
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateAccountsStorageCredential into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.aws_iam_role:
+            body["aws_iam_role"] = self.aws_iam_role
+        if self.azure_managed_identity:
+            body["azure_managed_identity"] = self.azure_managed_identity
+        if self.azure_service_principal:
+            body["azure_service_principal"] = self.azure_service_principal
+        if self.cloudflare_api_token:
+            body["cloudflare_api_token"] = self.cloudflare_api_token
+        if self.comment is not None:
+            body["comment"] = self.comment
+        if self.databricks_gcp_service_account:
+            body["databricks_gcp_service_account"] = self.databricks_gcp_service_account
+        if self.isolation_mode is not None:
+            body["isolation_mode"] = self.isolation_mode
+        if self.owner is not None:
+            body["owner"] = self.owner
+        if self.read_only is not None:
+            body["read_only"] = self.read_only
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> UpdateAccountsStorageCredential:
+        """Deserializes the UpdateAccountsStorageCredential from a dictionary."""
+        return cls(
+            aws_iam_role=_from_dict(d, "aws_iam_role", AwsIamRoleRequest),
+            azure_managed_identity=_from_dict(d, "azure_managed_identity", AzureManagedIdentityResponse),
+            azure_service_principal=_from_dict(d, "azure_service_principal", AzureServicePrincipal),
+            cloudflare_api_token=_from_dict(d, "cloudflare_api_token", CloudflareApiToken),
+            comment=d.get("comment", None),
+            databricks_gcp_service_account=_from_dict(
+                d, "databricks_gcp_service_account", DatabricksGcpServiceAccountRequest
+            ),
+            isolation_mode=_enum(d, "isolation_mode", IsolationMode),
+            owner=d.get("owner", None),
+            read_only=d.get("read_only", None),
+        )
+
+
+@dataclass
+class UpdateAssignmentResponse:
+    def as_dict(self) -> dict:
+        """Serializes the UpdateAssignmentResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateAssignmentResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> UpdateAssignmentResponse:
+        """Deserializes the UpdateAssignmentResponse from a dictionary."""
+        return cls()
+
+
+@dataclass
+class UpdateCatalogWorkspaceBindingsResponse:
+    workspaces: Optional[List[int]] = None
+    """A list of workspace IDs"""
+
+    def as_dict(self) -> dict:
+        """Serializes the UpdateCatalogWorkspaceBindingsResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.workspaces:
+            body["workspaces"] = [v for v in self.workspaces]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateCatalogWorkspaceBindingsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.workspaces:
+            body["workspaces"] = self.workspaces
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> UpdateCatalogWorkspaceBindingsResponse:
+        """Deserializes the UpdateCatalogWorkspaceBindingsResponse from a dictionary."""
+        return cls(workspaces=d.get("workspaces", None))
+
+
 @dataclass
 class UpdateMetastoreAssignment:
     default_catalog_name: Optional[str] = None
@@ -9860,184 +10160,58 @@ class UpdateRequestExternalLineage:
         if self.columns:
             body["columns"] = [v.as_dict() for v in self.columns]
         if self.id is not None:
-            body["id"] = self.id
-        if self.properties:
-            body["properties"] = self.properties
-        if self.source:
-            body["source"] = self.source.as_dict()
-        if self.target:
-            body["target"] = self.target.as_dict()
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateRequestExternalLineage into a shallow dictionary of its immediate attributes."""
-        body = {}
-        if self.columns:
-            body["columns"] = self.columns
-        if self.id is not None:
-            body["id"] = self.id
-        if self.properties:
-            body["properties"] = self.properties
-        if self.source:
-            body["source"] = self.source
-        if self.target:
-            body["target"] = self.target
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> UpdateRequestExternalLineage:
-        """Deserializes the UpdateRequestExternalLineage from a dictionary."""
-        return cls(
-            columns=_repeated_dict(d, "columns", ColumnRelationship),
-            id=d.get("id", None),
-            properties=d.get("properties", None),
-            source=_from_dict(d, "source", ExternalLineageObject),
-            target=_from_dict(d, "target", ExternalLineageObject),
-        )
-
-
-@dataclass
-class UpdateResponse:
-    def as_dict(self) -> dict:
-        """Serializes the UpdateResponse into a dictionary suitable for use as a JSON request body."""
-        body = {}
-        return body
-
-    def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateResponse into a shallow dictionary of its immediate attributes."""
-        body = {}
-        return body
-
-    @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> UpdateResponse:
-        """Deserializes the UpdateResponse from a dictionary."""
-        return cls()
-
-
-@dataclass
-class UpdateStorageCredential:
-    aws_iam_role: Optional[AwsIamRoleRequest] = None
-    """The AWS IAM role configuration."""
-
-    azure_managed_identity: Optional[AzureManagedIdentityResponse] = None
-    """The Azure managed identity configuration."""
-
-    azure_service_principal: Optional[AzureServicePrincipal] = None
-    """The Azure service principal configuration."""
-
-    cloudflare_api_token: Optional[CloudflareApiToken] = None
-    """The Cloudflare API token configuration."""
-
-    comment: Optional[str] = None
-    """Comment associated with the credential."""
-
-    databricks_gcp_service_account: Optional[DatabricksGcpServiceAccountRequest] = None
-    """The Databricks managed GCP service account configuration."""
-
-    force: Optional[bool] = None
-    """Force update even if there are dependent external locations or external tables."""
-
-    isolation_mode: Optional[IsolationMode] = None
-    """Whether the current securable is accessible from all workspaces or a specific set of workspaces."""
-
-    name: Optional[str] = None
-    """Name of the storage credential."""
-
-    new_name: Optional[str] = None
-    """New name for the storage credential."""
+            body["id"] = self.id
+        if self.properties:
+            body["properties"] = self.properties
+        if self.source:
+            body["source"] = self.source.as_dict()
+        if self.target:
+            body["target"] = self.target.as_dict()
+        return body
 
-    owner: Optional[str] = None
-    """Username of current owner of credential."""
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateRequestExternalLineage into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.columns:
+            body["columns"] = self.columns
+        if self.id is not None:
+            body["id"] = self.id
+        if self.properties:
+            body["properties"] = self.properties
+        if self.source:
+            body["source"] = self.source
+        if self.target:
+            body["target"] = self.target
+        return body
 
-    read_only: Optional[bool] = None
-    """Whether the credential is usable only for read operations. Only applicable when purpose is
-    **STORAGE**."""
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> UpdateRequestExternalLineage:
+        """Deserializes the UpdateRequestExternalLineage from a dictionary."""
+        return cls(
+            columns=_repeated_dict(d, "columns", ColumnRelationship),
+            id=d.get("id", None),
+            properties=d.get("properties", None),
+            source=_from_dict(d, "source", ExternalLineageObject),
+            target=_from_dict(d, "target", ExternalLineageObject),
+        )
 
-    skip_validation: Optional[bool] = None
-    """Supplying true to this argument skips validation of the updated credential."""
 
+@dataclass
+class UpdateResponse:
     def as_dict(self) -> dict:
-        """Serializes the UpdateStorageCredential into a dictionary suitable for use as a JSON request body."""
+        """Serializes the UpdateResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.aws_iam_role:
-            body["aws_iam_role"] = self.aws_iam_role.as_dict()
-        if self.azure_managed_identity:
-            body["azure_managed_identity"] = self.azure_managed_identity.as_dict()
-        if self.azure_service_principal:
-            body["azure_service_principal"] = self.azure_service_principal.as_dict()
-        if self.cloudflare_api_token:
-            body["cloudflare_api_token"] = self.cloudflare_api_token.as_dict()
-        if self.comment is not None:
-            body["comment"] = self.comment
-        if self.databricks_gcp_service_account:
-            body["databricks_gcp_service_account"] = self.databricks_gcp_service_account.as_dict()
-        if self.force is not None:
-            body["force"] = self.force
-        if self.isolation_mode is not None:
-            body["isolation_mode"] = self.isolation_mode.value
-        if self.name is not None:
-            body["name"] = self.name
-        if self.new_name is not None:
-            body["new_name"] = self.new_name
-        if self.owner is not None:
-            body["owner"] = self.owner
-        if self.read_only is not None:
-            body["read_only"] = self.read_only
-        if self.skip_validation is not None:
-            body["skip_validation"] = self.skip_validation
         return body
 
     def as_shallow_dict(self) -> dict:
-        """Serializes the UpdateStorageCredential into a shallow dictionary of its immediate attributes."""
+        """Serializes the UpdateResponse into a shallow dictionary of its immediate attributes."""
         body = {}
-        if self.aws_iam_role:
-            body["aws_iam_role"] = self.aws_iam_role
-        if self.azure_managed_identity:
-            body["azure_managed_identity"] = self.azure_managed_identity
-        if self.azure_service_principal:
-            body["azure_service_principal"] = self.azure_service_principal
-        if self.cloudflare_api_token:
-            body["cloudflare_api_token"] = self.cloudflare_api_token
-        if self.comment is not None:
-            body["comment"] = self.comment
-        if self.databricks_gcp_service_account:
-            body["databricks_gcp_service_account"] = self.databricks_gcp_service_account
-        if self.force is not None:
-            body["force"] = self.force
-        if self.isolation_mode is not None:
-            body["isolation_mode"] = self.isolation_mode
-        if self.name is not None:
-            body["name"] = self.name
-        if self.new_name is not None:
-            body["new_name"] = self.new_name
-        if self.owner is not None:
-            body["owner"] = self.owner
-        if self.read_only is not None:
-            body["read_only"] = self.read_only
-        if self.skip_validation is not None:
-            body["skip_validation"] = self.skip_validation
         return body
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> UpdateStorageCredential:
-        """Deserializes the UpdateStorageCredential from a dictionary."""
-        return cls(
-            aws_iam_role=_from_dict(d, "aws_iam_role", AwsIamRoleRequest),
-            azure_managed_identity=_from_dict(d, "azure_managed_identity", AzureManagedIdentityResponse),
-            azure_service_principal=_from_dict(d, "azure_service_principal", AzureServicePrincipal),
-            cloudflare_api_token=_from_dict(d, "cloudflare_api_token", CloudflareApiToken),
-            comment=d.get("comment", None),
-            databricks_gcp_service_account=_from_dict(
-                d, "databricks_gcp_service_account", DatabricksGcpServiceAccountRequest
-            ),
-            force=d.get("force", None),
-            isolation_mode=_enum(d, "isolation_mode", IsolationMode),
-            name=d.get("name", None),
-            new_name=d.get("new_name", None),
-            owner=d.get("owner", None),
-            read_only=d.get("read_only", None),
-            skip_validation=d.get("skip_validation", None),
-        )
+    def from_dict(cls, d: Dict[str, Any]) -> UpdateResponse:
+        """Deserializes the UpdateResponse from a dictionary."""
+        return cls()
 
 
 @dataclass
@@ -10415,7 +10589,7 @@ class AccountMetastoreAssignmentsAPI:
 
     def create(
         self, workspace_id: int, metastore_id: str, *, metastore_assignment: Optional[CreateMetastoreAssignment] = None
-    ):
+    ) -> AccountsCreateMetastoreAssignmentResponse:
         """Creates an assignment to a metastore for a workspace
 
         :param workspace_id: int
@@ -10424,7 +10598,7 @@ class AccountMetastoreAssignmentsAPI:
           Unity Catalog metastore ID
         :param metastore_assignment: :class:`CreateMetastoreAssignment` (optional)
 
-
+        :returns: :class:`AccountsCreateMetastoreAssignmentResponse`
         """
         body = {}
         if metastore_assignment is not None:
@@ -10434,14 +10608,15 @@ class AccountMetastoreAssignmentsAPI:
             "Content-Type": "application/json",
         }
 
-        self._api.do(
+        res = self._api.do(
             "POST",
             f"/api/2.0/accounts/{self._api.account_id}/workspaces/{workspace_id}/metastores/{metastore_id}",
             body=body,
             headers=headers,
         )
+        return AccountsCreateMetastoreAssignmentResponse.from_dict(res)
 
-    def delete(self, workspace_id: int, metastore_id: str):
+    def delete(self, workspace_id: int, metastore_id: str) -> AccountsDeleteMetastoreAssignmentResponse:
         """Deletes a metastore assignment to a workspace, leaving the workspace with no metastore.
 
         :param workspace_id: int
@@ -10449,23 +10624,24 @@ class AccountMetastoreAssignmentsAPI:
         :param metastore_id: str
           Unity Catalog metastore ID
 
-
+        :returns: :class:`AccountsDeleteMetastoreAssignmentResponse`
         """
 
         headers = {
             "Accept": "application/json",
         }
 
-        self._api.do(
+        res = self._api.do(
             "DELETE",
             f"/api/2.0/accounts/{self._api.account_id}/workspaces/{workspace_id}/metastores/{metastore_id}",
             headers=headers,
         )
+        return AccountsDeleteMetastoreAssignmentResponse.from_dict(res)
 
     def get(self, workspace_id: int) -> AccountsMetastoreAssignment:
         """Gets the metastore assignment, if any, for the workspace specified by ID. If the workspace is assigned
-        a metastore, the mappig will be returned. If no metastore is assigned to the workspace, the assignment
-        will not be found and a 404 returned.
+        a metastore, the mapping will be returned. If no metastore is assigned to the workspace, the
+        assignment will not be found and a 404 returned.
 
         :param workspace_id: int
           Workspace ID.
@@ -10503,7 +10679,7 @@ class AccountMetastoreAssignmentsAPI:
 
     def update(
         self, workspace_id: int, metastore_id: str, *, metastore_assignment: Optional[UpdateMetastoreAssignment] = None
-    ):
+    ) -> AccountsUpdateMetastoreAssignmentResponse:
         """Updates an assignment to a metastore for a workspace. Currently, only the default catalog may be
         updated.
 
@@ -10513,7 +10689,7 @@ class AccountMetastoreAssignmentsAPI:
           Unity Catalog metastore ID
         :param metastore_assignment: :class:`UpdateMetastoreAssignment` (optional)
 
-
+        :returns: :class:`AccountsUpdateMetastoreAssignmentResponse`
         """
         body = {}
         if metastore_assignment is not None:
@@ -10523,12 +10699,13 @@ class AccountMetastoreAssignmentsAPI:
             "Content-Type": "application/json",
         }
 
-        self._api.do(
+        res = self._api.do(
             "PUT",
             f"/api/2.0/accounts/{self._api.account_id}/workspaces/{workspace_id}/metastores/{metastore_id}",
             body=body,
             headers=headers,
         )
+        return AccountsUpdateMetastoreAssignmentResponse.from_dict(res)
 
 
 class AccountMetastoresAPI:
@@ -10538,12 +10715,12 @@ class AccountMetastoresAPI:
     def __init__(self, api_client):
         self._api = api_client
 
-    def create(self, *, metastore_info: Optional[CreateMetastore] = None) -> AccountsMetastoreInfo:
+    def create(self, *, metastore_info: Optional[CreateAccountsMetastore] = None) -> AccountsCreateMetastoreResponse:
         """Creates a Unity Catalog metastore.
 
-        :param metastore_info: :class:`CreateMetastore` (optional)
+        :param metastore_info: :class:`CreateAccountsMetastore` (optional)
 
-        :returns: :class:`AccountsMetastoreInfo`
+        :returns: :class:`AccountsCreateMetastoreResponse`
         """
         body = {}
         if metastore_info is not None:
@@ -10554,9 +10731,9 @@ class AccountMetastoresAPI:
         }
 
         res = self._api.do("POST", f"/api/2.0/accounts/{self._api.account_id}/metastores", body=body, headers=headers)
-        return AccountsMetastoreInfo.from_dict(res)
+        return AccountsCreateMetastoreResponse.from_dict(res)
 
-    def delete(self, metastore_id: str, *, force: Optional[bool] = None):
+    def delete(self, metastore_id: str, *, force: Optional[bool] = None) -> AccountsDeleteMetastoreResponse:
         """Deletes a Unity Catalog metastore for an account, both specified by ID.
 
         :param metastore_id: str
@@ -10564,7 +10741,7 @@ class AccountMetastoresAPI:
         :param force: bool (optional)
           Force deletion even if the metastore is not empty. Default is false.
 
-
+        :returns: :class:`AccountsDeleteMetastoreResponse`
         """
 
         query = {}
@@ -10574,20 +10751,21 @@ class AccountMetastoresAPI:
             "Accept": "application/json",
         }
 
-        self._api.do(
+        res = self._api.do(
             "DELETE",
             f"/api/2.0/accounts/{self._api.account_id}/metastores/{metastore_id}",
             query=query,
             headers=headers,
         )
+        return AccountsDeleteMetastoreResponse.from_dict(res)
 
-    def get(self, metastore_id: str) -> AccountsMetastoreInfo:
+    def get(self, metastore_id: str) -> AccountsGetMetastoreResponse:
         """Gets a Unity Catalog metastore from an account, both specified by ID.
 
         :param metastore_id: str
           Unity Catalog metastore ID
 
-        :returns: :class:`AccountsMetastoreInfo`
+        :returns: :class:`AccountsGetMetastoreResponse`
         """
 
         headers = {
@@ -10597,7 +10775,7 @@ class AccountMetastoresAPI:
         res = self._api.do(
             "GET", f"/api/2.0/accounts/{self._api.account_id}/metastores/{metastore_id}", headers=headers
         )
-        return AccountsMetastoreInfo.from_dict(res)
+        return AccountsGetMetastoreResponse.from_dict(res)
 
     def list(self) -> Iterator[MetastoreInfo]:
         """Gets all Unity Catalog metastores associated with an account specified by ID.
@@ -10611,17 +10789,20 @@ class AccountMetastoresAPI:
         }
 
         json = self._api.do("GET", f"/api/2.0/accounts/{self._api.account_id}/metastores", headers=headers)
-        parsed = ListMetastoresResponse.from_dict(json).metastores
+        parsed = AccountsListMetastoresResponse.from_dict(json).metastores
         return parsed if parsed is not None else []
 
-    def update(self, metastore_id: str, *, metastore_info: Optional[UpdateMetastore] = None) -> AccountsMetastoreInfo:
+    def update(
+        self, metastore_id: str, *, metastore_info: Optional[UpdateAccountsMetastore] = None
+    ) -> AccountsUpdateMetastoreResponse:
         """Updates an existing Unity Catalog metastore.
 
         :param metastore_id: str
           Unity Catalog metastore ID
-        :param metastore_info: :class:`UpdateMetastore` (optional)
+        :param metastore_info: :class:`UpdateAccountsMetastore` (optional)
+          Properties of the metastore to change.
 
-        :returns: :class:`AccountsMetastoreInfo`
+        :returns: :class:`AccountsUpdateMetastoreResponse`
         """
         body = {}
         if metastore_info is not None:
@@ -10634,7 +10815,7 @@ class AccountMetastoresAPI:
         res = self._api.do(
             "PUT", f"/api/2.0/accounts/{self._api.account_id}/metastores/{metastore_id}", body=body, headers=headers
         )
-        return AccountsMetastoreInfo.from_dict(res)
+        return AccountsUpdateMetastoreResponse.from_dict(res)
 
 
 class AccountStorageCredentialsAPI:
@@ -10644,25 +10825,33 @@ class AccountStorageCredentialsAPI:
         self._api = api_client
 
     def create(
-        self, metastore_id: str, *, credential_info: Optional[CreateStorageCredential] = None
-    ) -> AccountsStorageCredentialInfo:
-        """Creates a new storage credential. The request object is specific to the cloud:
-
-        * **AwsIamRole** for AWS credentials * **AzureServicePrincipal** for Azure credentials *
-        **GcpServiceAcountKey** for GCP credentials.
+        self,
+        metastore_id: str,
+        *,
+        credential_info: Optional[CreateAccountsStorageCredential] = None,
+        skip_validation: Optional[bool] = None,
+    ) -> AccountsCreateStorageCredentialInfo:
+        """Creates a new storage credential. The request object is specific to the cloud: - **AwsIamRole** for
+        AWS credentials - **AzureServicePrincipal** for Azure credentials - **GcpServiceAccountKey** for GCP
+        credentials
 
-        The caller must be a metastore admin and have the **CREATE_STORAGE_CREDENTIAL** privilege on the
+        The caller must be a metastore admin and have the `CREATE_STORAGE_CREDENTIAL` privilege on the
         metastore.
 
         :param metastore_id: str
           Unity Catalog metastore ID
-        :param credential_info: :class:`CreateStorageCredential` (optional)
+        :param credential_info: :class:`CreateAccountsStorageCredential` (optional)
+        :param skip_validation: bool (optional)
+          Optional, default false. Supplying true to this argument skips validation of the created set of
+          credentials.
 
-        :returns: :class:`AccountsStorageCredentialInfo`
+        :returns: :class:`AccountsCreateStorageCredentialInfo`
         """
         body = {}
         if credential_info is not None:
             body["credential_info"] = credential_info.as_dict()
+        if skip_validation is not None:
+            body["skip_validation"] = skip_validation
         headers = {
             "Accept": "application/json",
             "Content-Type": "application/json",
@@ -10674,9 +10863,11 @@ class AccountStorageCredentialsAPI:
             body=body,
             headers=headers,
         )
-        return AccountsStorageCredentialInfo.from_dict(res)
+        return AccountsCreateStorageCredentialInfo.from_dict(res)
 
-    def delete(self, metastore_id: str, storage_credential_name: str, *, force: Optional[bool] = None):
+    def delete(
+        self, metastore_id: str, storage_credential_name: str, *, force: Optional[bool] = None
+    ) -> AccountsDeleteStorageCredentialResponse:
         """Deletes a storage credential from the metastore. The caller must be an owner of the storage
         credential.
 
@@ -10687,7 +10878,7 @@ class AccountStorageCredentialsAPI:
         :param force: bool (optional)
           Force deletion even if the Storage Credential is not empty. Default is false.
 
-
+        :returns: :class:`AccountsDeleteStorageCredentialResponse`
         """
 
         query = {}
@@ -10697,12 +10888,13 @@ class AccountStorageCredentialsAPI:
             "Accept": "application/json",
         }
 
-        self._api.do(
+        res = self._api.do(
             "DELETE",
             f"/api/2.0/accounts/{self._api.account_id}/metastores/{metastore_id}/storage-credentials/{storage_credential_name}",
             query=query,
             headers=headers,
         )
+        return AccountsDeleteStorageCredentialResponse.from_dict(res)
 
     def get(self, metastore_id: str, storage_credential_name: str) -> AccountsStorageCredentialInfo:
         """Gets a storage credential from the metastore. The caller must be a metastore admin, the owner of the
@@ -10711,7 +10903,7 @@ class AccountStorageCredentialsAPI:
         :param metastore_id: str
           Unity Catalog metastore ID
         :param storage_credential_name: str
-          Name of the storage credential.
+          Required. Name of the storage credential.
 
         :returns: :class:`AccountsStorageCredentialInfo`
         """
@@ -10753,22 +10945,27 @@ class AccountStorageCredentialsAPI:
         metastore_id: str,
         storage_credential_name: str,
         *,
-        credential_info: Optional[UpdateStorageCredential] = None,
-    ) -> AccountsStorageCredentialInfo:
+        credential_info: Optional[UpdateAccountsStorageCredential] = None,
+        skip_validation: Optional[bool] = None,
+    ) -> AccountsUpdateStorageCredentialResponse:
         """Updates a storage credential on the metastore. The caller must be the owner of the storage credential.
-        If the caller is a metastore admin, only the __owner__ credential can be changed.
+        If the caller is a metastore admin, only the **owner** credential can be changed.
 
         :param metastore_id: str
           Unity Catalog metastore ID
         :param storage_credential_name: str
           Name of the storage credential.
-        :param credential_info: :class:`UpdateStorageCredential` (optional)
+        :param credential_info: :class:`UpdateAccountsStorageCredential` (optional)
+        :param skip_validation: bool (optional)
+          Optional. Supplying true to this argument skips validation of the updated set of credentials.
 
-        :returns: :class:`AccountsStorageCredentialInfo`
+        :returns: :class:`AccountsUpdateStorageCredentialResponse`
         """
         body = {}
         if credential_info is not None:
             body["credential_info"] = credential_info.as_dict()
+        if skip_validation is not None:
+            body["skip_validation"] = skip_validation
         headers = {
             "Accept": "application/json",
             "Content-Type": "application/json",
@@ -10780,7 +10977,7 @@ class AccountStorageCredentialsAPI:
             body=body,
             headers=headers,
         )
-        return AccountsStorageCredentialInfo.from_dict(res)
+        return AccountsUpdateStorageCredentialResponse.from_dict(res)
 
 
 class ArtifactAllowlistsAPI:
@@ -10973,6 +11170,7 @@ class CatalogsAPI:
         self,
         *,
         include_browse: Optional[bool] = None,
+        include_unbound: Optional[bool] = None,
         max_results: Optional[int] = None,
         page_token: Optional[str] = None,
     ) -> Iterator[CatalogInfo]:
@@ -10981,9 +11179,20 @@ class CatalogsAPI:
         **USE_CATALOG** privilege) will be retrieved. There is no guarantee of a specific ordering of the
         elements in the array.
 
+        NOTE: we recommend using max_results=0 to use the paginated version of this API. Unpaginated calls
+        will be deprecated soon.
+
+        PAGINATION BEHAVIOR: When using pagination (max_results >= 0), a page may contain zero results while
+        still providing a next_page_token. Clients must continue reading pages until next_page_token is
+        absent, which is the only indication that the end of results has been reached. This behavior follows
+        Google AIP-158 guidelines.
+
         :param include_browse: bool (optional)
           Whether to include catalogs in the response for which the principal can only access selective
           metadata for
+        :param include_unbound: bool (optional)
+          Whether to include catalogs not bound to the workspace. Effective only if the user has permission to
+          update the catalog–workspace binding.
         :param max_results: int (optional)
           Maximum number of catalogs to return. - when set to 0, the page length is set to a server configured
           value (recommended); - when set to a value greater than 0, the page length is the minimum of this
@@ -11001,6 +11210,8 @@ class CatalogsAPI:
         query = {}
         if include_browse is not None:
             query["include_browse"] = include_browse
+        if include_unbound is not None:
+            query["include_unbound"] = include_unbound
         if max_results is not None:
             query["max_results"] = max_results
         if page_token is not None:
@@ -11174,6 +11385,14 @@ class ConnectionsAPI:
     def list(self, *, max_results: Optional[int] = None, page_token: Optional[str] = None) -> Iterator[ConnectionInfo]:
         """List all connections.
 
+        NOTE: we recommend using max_results=0 to use the paginated version of this API. Unpaginated calls
+        will be deprecated soon.
+
+        PAGINATION BEHAVIOR: When using pagination (max_results >= 0), a page may contain zero results while
+        still providing a next_page_token. Clients must continue reading pages until next_page_token is
+        absent, which is the only indication that the end of results has been reached. This behavior follows
+        Google AIP-158 guidelines.
+
         :param max_results: int (optional)
           Maximum number of connections to return. - If not set, all connections are returned (not
           recommended). - when set to a value greater than 0, the page length is the minimum of this value and
@@ -11390,6 +11609,7 @@ class CredentialsAPI:
     def list_credentials(
         self,
         *,
+        include_unbound: Optional[bool] = None,
         max_results: Optional[int] = None,
         page_token: Optional[str] = None,
         purpose: Optional[CredentialPurpose] = None,
@@ -11400,6 +11620,9 @@ class CredentialsAPI:
         is a metastore admin, retrieval of credentials is unrestricted. There is no guarantee of a specific
         ordering of the elements in the array.
 
+        :param include_unbound: bool (optional)
+          Whether to include credentials not bound to the workspace. Effective only if the user has permission
+          to update the credential–workspace binding.
         :param max_results: int (optional)
           Maximum number of credentials to return. - If not set, the default max page size is used. - When set
           to a value greater than 0, the page length is the minimum of this value and a server-configured
@@ -11414,6 +11637,8 @@ class CredentialsAPI:
         """
 
         query = {}
+        if include_unbound is not None:
+            query["include_unbound"] = include_unbound
         if max_results is not None:
             query["max_results"] = max_results
         if page_token is not None:
@@ -12037,6 +12262,7 @@ class ExternalLocationsAPI:
         self,
         *,
         include_browse: Optional[bool] = None,
+        include_unbound: Optional[bool] = None,
         max_results: Optional[int] = None,
         page_token: Optional[str] = None,
     ) -> Iterator[ExternalLocationInfo]:
@@ -12044,9 +12270,20 @@ class ExternalLocationsAPI:
         must be a metastore admin, the owner of the external location, or a user that has some privilege on
         the external location. There is no guarantee of a specific ordering of the elements in the array.
 
+        NOTE: we recommend using max_results=0 to use the paginated version of this API. Unpaginated calls
+        will be deprecated soon.
+
+        PAGINATION BEHAVIOR: When using pagination (max_results >= 0), a page may contain zero results while
+        still providing a next_page_token. Clients must continue reading pages until next_page_token is
+        absent, which is the only indication that the end of results has been reached. This behavior follows
+        Google AIP-158 guidelines.
+
         :param include_browse: bool (optional)
           Whether to include external locations in the response for which the principal can only access
           selective metadata for
+        :param include_unbound: bool (optional)
+          Whether to include external locations not bound to the workspace. Effective only if the user has
+          permission to update the location–workspace binding.
         :param max_results: int (optional)
           Maximum number of external locations to return. If not set, all the external locations are returned
           (not recommended). - when set to a value greater than 0, the page length is the minimum of this
@@ -12061,6 +12298,8 @@ class ExternalLocationsAPI:
         query = {}
         if include_browse is not None:
             query["include_browse"] = include_browse
+        if include_unbound is not None:
+            query["include_unbound"] = include_unbound
         if max_results is not None:
             query["max_results"] = max_results
         if page_token is not None:
@@ -12346,7 +12585,7 @@ class FunctionsAPI:
 
         :param name: str
           The fully-qualified name of the function (of the form
-          __catalog_name__.__schema_name__.__function__name__).
+          __catalog_name__.__schema_name__.__function__name__) .
         :param force: bool (optional)
           Force deletion even if the function is notempty.
 
@@ -12356,9 +12595,7 @@ class FunctionsAPI:
         query = {}
         if force is not None:
             query["force"] = force
-        headers = {
-            "Accept": "application/json",
-        }
+        headers = {}
 
         self._api.do("DELETE", f"/api/2.1/unity-catalog/functions/{name}", query=query, headers=headers)
 
@@ -12405,6 +12642,14 @@ class FunctionsAPI:
         functions for which either the user has the **EXECUTE** privilege or the user is the owner. There is
         no guarantee of a specific ordering of the elements in the array.
 
+        NOTE: we recommend using max_results=0 to use the paginated version of this API. Unpaginated calls
+        will be deprecated soon.
+
+        PAGINATION BEHAVIOR: When using pagination (max_results >= 0), a page may contain zero results while
+        still providing a next_page_token. Clients must continue reading pages until next_page_token is
+        absent, which is the only indication that the end of results has been reached. This behavior follows
+        Google AIP-158 guidelines.
+
         :param catalog_name: str
           Name of parent catalog for functions of interest.
         :param schema_name: str
@@ -12459,7 +12704,7 @@ class FunctionsAPI:
           The fully-qualified name of the function (of the form
           __catalog_name__.__schema_name__.__function__name__).
         :param owner: str (optional)
-          Username of current owner of function.
+          Username of current owner of the function.
 
         :returns: :class:`FunctionInfo`
         """
@@ -12749,6 +12994,14 @@ class MetastoresAPI:
         """Gets an array of the available metastores (as __MetastoreInfo__ objects). The caller must be an admin
         to retrieve this info. There is no guarantee of a specific ordering of the elements in the array.
 
+        NOTE: we recommend using max_results=0 to use the paginated version of this API. Unpaginated calls
+        will be deprecated soon.
+
+        PAGINATION BEHAVIOR: When using pagination (max_results >= 0), a page may contain zero results while
+        still providing a next_page_token. Clients must continue reading pages until next_page_token is
+        absent, which is the only indication that the end of results has been reached. This behavior follows
+        Google AIP-158 guidelines.
+
         :param max_results: int (optional)
           Maximum number of metastores to return. - 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
@@ -13069,7 +13322,29 @@ class ModelVersionsAPI:
                 return
             query["page_token"] = json["next_page_token"]
 
-    def update(self, full_name: str, version: int, *, comment: Optional[str] = None) -> ModelVersionInfo:
+    def update(
+        self,
+        full_name: str,
+        version: int,
+        *,
+        aliases: Optional[List[RegisteredModelAlias]] = None,
+        catalog_name: Optional[str] = None,
+        comment: Optional[str] = None,
+        created_at: Optional[int] = None,
+        created_by: Optional[str] = None,
+        id: Optional[str] = None,
+        metastore_id: Optional[str] = None,
+        model_name: Optional[str] = None,
+        model_version_dependencies: Optional[DependencyList] = None,
+        run_id: Optional[str] = None,
+        run_workspace_id: Optional[int] = None,
+        schema_name: Optional[str] = None,
+        source: Optional[str] = None,
+        status: Optional[ModelVersionInfoStatus] = None,
+        storage_location: Optional[str] = None,
+        updated_at: Optional[int] = None,
+        updated_by: Optional[str] = None,
+    ) -> ModelVersionInfo:
         """Updates the specified model version.
 
         The caller must be a metastore admin or an owner of the parent registered model. For the latter case,
@@ -13082,14 +13357,80 @@ class ModelVersionsAPI:
           The three-level (fully qualified) name of the model version
         :param version: int
           The integer version number of the model version
+        :param aliases: List[:class:`RegisteredModelAlias`] (optional)
+          List of aliases associated with the model version
+        :param catalog_name: str (optional)
+          The name of the catalog containing the model version
         :param comment: str (optional)
           The comment attached to the model version
+        :param created_at: int (optional)
+        :param created_by: str (optional)
+          The identifier of the user who created the model version
+        :param id: str (optional)
+          The unique identifier of the model version
+        :param metastore_id: str (optional)
+          The unique identifier of the metastore containing the model version
+        :param model_name: str (optional)
+          The name of the parent registered model of the model version, relative to parent schema
+        :param model_version_dependencies: :class:`DependencyList` (optional)
+          Model version dependencies, for feature-store packaged models
+        :param run_id: str (optional)
+          MLflow run ID used when creating the model version, if ``source`` was generated by an experiment run
+          stored in an MLflow tracking server
+        :param run_workspace_id: int (optional)
+          ID of the Databricks workspace containing the MLflow run that generated this model version, if
+          applicable
+        :param schema_name: str (optional)
+          The name of the schema containing the model version, relative to parent catalog
+        :param source: str (optional)
+          URI indicating the location of the source artifacts (files) for the model version
+        :param status: :class:`ModelVersionInfoStatus` (optional)
+          Current status of the model version. Newly created model versions start in PENDING_REGISTRATION
+          status, then move to READY status once the model version files are uploaded and the model version is
+          finalized. Only model versions in READY status can be loaded for inference or served.
+        :param storage_location: str (optional)
+          The storage location on the cloud under which model version data files are stored
+        :param updated_at: int (optional)
+        :param updated_by: str (optional)
+          The identifier of the user who updated the model version last time
 
         :returns: :class:`ModelVersionInfo`
         """
         body = {}
+        if aliases is not None:
+            body["aliases"] = [v.as_dict() for v in aliases]
+        if catalog_name is not None:
+            body["catalog_name"] = catalog_name
         if comment is not None:
             body["comment"] = comment
+        if created_at is not None:
+            body["created_at"] = created_at
+        if created_by is not None:
+            body["created_by"] = created_by
+        if id is not None:
+            body["id"] = id
+        if metastore_id is not None:
+            body["metastore_id"] = metastore_id
+        if model_name is not None:
+            body["model_name"] = model_name
+        if model_version_dependencies is not None:
+            body["model_version_dependencies"] = model_version_dependencies.as_dict()
+        if run_id is not None:
+            body["run_id"] = run_id
+        if run_workspace_id is not None:
+            body["run_workspace_id"] = run_workspace_id
+        if schema_name is not None:
+            body["schema_name"] = schema_name
+        if source is not None:
+            body["source"] = source
+        if status is not None:
+            body["status"] = status.value
+        if storage_location is not None:
+            body["storage_location"] = storage_location
+        if updated_at is not None:
+            body["updated_at"] = updated_at
+        if updated_by is not None:
+            body["updated_by"] = updated_by
         headers = {
             "Accept": "application/json",
             "Content-Type": "application/json",
@@ -13797,20 +14138,29 @@ class RegisteredModelsAPI:
     new model version, or update permissions on the registered model, users must be owners of the registered
     model.
 
-    Note: The securable type for models is "FUNCTION". When using REST APIs (e.g. tagging, grants) that
-    specify a securable type, use "FUNCTION" as the securable type."""
+    Note: The securable type for models is FUNCTION. When using REST APIs (e.g. tagging, grants) that specify
+    a securable type, use FUNCTION as the securable type."""
 
     def __init__(self, api_client):
         self._api = api_client
 
     def create(
         self,
-        catalog_name: str,
-        schema_name: str,
-        name: str,
         *,
+        aliases: Optional[List[RegisteredModelAlias]] = None,
+        browse_only: Optional[bool] = None,
+        catalog_name: Optional[str] = None,
         comment: Optional[str] = None,
+        created_at: Optional[int] = None,
+        created_by: Optional[str] = None,
+        full_name: Optional[str] = None,
+        metastore_id: Optional[str] = None,
+        name: Optional[str] = None,
+        owner: Optional[str] = None,
+        schema_name: Optional[str] = None,
         storage_location: Optional[str] = None,
+        updated_at: Optional[int] = None,
+        updated_by: Optional[str] = None,
     ) -> RegisteredModelInfo:
         """Creates a new registered model in Unity Catalog.
 
@@ -13822,30 +14172,67 @@ class RegisteredModelsAPI:
         **USE_CATALOG** privilege on the parent catalog and the **USE_SCHEMA** privilege on the parent schema.
         - The caller must have the **CREATE MODEL** or **CREATE FUNCTION** privilege on the parent schema.
 
-        :param catalog_name: str
+        :param aliases: List[:class:`RegisteredModelAlias`] (optional)
+          List of aliases associated with the registered model
+        :param browse_only: bool (optional)
+          Indicates whether the principal is limited to retrieving metadata for the associated object through
+          the BROWSE privilege when include_browse is enabled in the request.
+        :param catalog_name: str (optional)
           The name of the catalog where the schema and the registered model reside
-        :param schema_name: str
-          The name of the schema where the registered model resides
-        :param name: str
-          The name of the registered model
         :param comment: str (optional)
           The comment attached to the registered model
+        :param created_at: int (optional)
+          Creation timestamp of the registered model in milliseconds since the Unix epoch
+        :param created_by: str (optional)
+          The identifier of the user who created the registered model
+        :param full_name: str (optional)
+          The three-level (fully qualified) name of the registered model
+        :param metastore_id: str (optional)
+          The unique identifier of the metastore
+        :param name: str (optional)
+          The name of the registered model
+        :param owner: str (optional)
+          The identifier of the user who owns the registered model
+        :param schema_name: str (optional)
+          The name of the schema where the registered model resides
         :param storage_location: str (optional)
           The storage location on the cloud under which model version data files are stored
+        :param updated_at: int (optional)
+          Last-update timestamp of the registered model in milliseconds since the Unix epoch
+        :param updated_by: str (optional)
+          The identifier of the user who updated the registered model last time
 
         :returns: :class:`RegisteredModelInfo`
         """
         body = {}
+        if aliases is not None:
+            body["aliases"] = [v.as_dict() for v in aliases]
+        if browse_only is not None:
+            body["browse_only"] = browse_only
         if catalog_name is not None:
             body["catalog_name"] = catalog_name
         if comment is not None:
             body["comment"] = comment
+        if created_at is not None:
+            body["created_at"] = created_at
+        if created_by is not None:
+            body["created_by"] = created_by
+        if full_name is not None:
+            body["full_name"] = full_name
+        if metastore_id is not None:
+            body["metastore_id"] = metastore_id
         if name is not None:
             body["name"] = name
+        if owner is not None:
+            body["owner"] = owner
         if schema_name is not None:
             body["schema_name"] = schema_name
         if storage_location is not None:
             body["storage_location"] = storage_location
+        if updated_at is not None:
+            body["updated_at"] = updated_at
+        if updated_by is not None:
+            body["updated_by"] = updated_by
         headers = {
             "Accept": "application/json",
             "Content-Type": "application/json",
@@ -14003,7 +14390,7 @@ class RegisteredModelsAPI:
         **USE_SCHEMA** privilege on the parent schema.
 
         :param full_name: str
-          Full name of the registered model
+          The three-level (fully qualified) name of the registered model
         :param alias: str
           The name of the alias
         :param version_num: int
@@ -14028,9 +14415,20 @@ class RegisteredModelsAPI:
         self,
         full_name: str,
         *,
+        aliases: Optional[List[RegisteredModelAlias]] = None,
+        browse_only: Optional[bool] = None,
+        catalog_name: Optional[str] = None,
         comment: Optional[str] = None,
+        created_at: Optional[int] = None,
+        created_by: Optional[str] = None,
+        metastore_id: Optional[str] = None,
+        name: Optional[str] = None,
         new_name: Optional[str] = None,
         owner: Optional[str] = None,
+        schema_name: Optional[str] = None,
+        storage_location: Optional[str] = None,
+        updated_at: Optional[int] = None,
+        updated_by: Optional[str] = None,
     ) -> RegisteredModelInfo:
         """Updates the specified registered model.
 
@@ -14042,22 +14440,67 @@ class RegisteredModelsAPI:
 
         :param full_name: str
           The three-level (fully qualified) name of the registered model
+        :param aliases: List[:class:`RegisteredModelAlias`] (optional)
+          List of aliases associated with the registered model
+        :param browse_only: bool (optional)
+          Indicates whether the principal is limited to retrieving metadata for the associated object through
+          the BROWSE privilege when include_browse is enabled in the request.
+        :param catalog_name: str (optional)
+          The name of the catalog where the schema and the registered model reside
         :param comment: str (optional)
           The comment attached to the registered model
+        :param created_at: int (optional)
+          Creation timestamp of the registered model in milliseconds since the Unix epoch
+        :param created_by: str (optional)
+          The identifier of the user who created the registered model
+        :param metastore_id: str (optional)
+          The unique identifier of the metastore
+        :param name: str (optional)
+          The name of the registered model
         :param new_name: str (optional)
           New name for the registered model.
         :param owner: str (optional)
           The identifier of the user who owns the registered model
+        :param schema_name: str (optional)
+          The name of the schema where the registered model resides
+        :param storage_location: str (optional)
+          The storage location on the cloud under which model version data files are stored
+        :param updated_at: int (optional)
+          Last-update timestamp of the registered model in milliseconds since the Unix epoch
+        :param updated_by: str (optional)
+          The identifier of the user who updated the registered model last time
 
         :returns: :class:`RegisteredModelInfo`
         """
         body = {}
+        if aliases is not None:
+            body["aliases"] = [v.as_dict() for v in aliases]
+        if browse_only is not None:
+            body["browse_only"] = browse_only
+        if catalog_name is not None:
+            body["catalog_name"] = catalog_name
         if comment is not None:
             body["comment"] = comment
+        if created_at is not None:
+            body["created_at"] = created_at
+        if created_by is not None:
+            body["created_by"] = created_by
+        if metastore_id is not None:
+            body["metastore_id"] = metastore_id
+        if name is not None:
+            body["name"] = name
         if new_name is not None:
             body["new_name"] = new_name
         if owner is not None:
             body["owner"] = owner
+        if schema_name is not None:
+            body["schema_name"] = schema_name
+        if storage_location is not None:
+            body["storage_location"] = storage_location
+        if updated_at is not None:
+            body["updated_at"] = updated_at
+        if updated_by is not None:
+            body["updated_by"] = updated_by
         headers = {
             "Accept": "application/json",
             "Content-Type": "application/json",
@@ -14356,6 +14799,14 @@ class SchemasAPI:
         owned by the caller (or for which the caller has the **USE_SCHEMA** privilege) will be retrieved.
         There is no guarantee of a specific ordering of the elements in the array.
 
+        NOTE: we recommend using max_results=0 to use the paginated version of this API. Unpaginated calls
+        will be deprecated soon.
+
+        PAGINATION BEHAVIOR: When using pagination (max_results >= 0), a page may contain zero results while
+        still providing a next_page_token. Clients must continue reading pages until next_page_token is
+        absent, which is the only indication that the end of results has been reached. This behavior follows
+        Google AIP-158 guidelines.
+
         :param catalog_name: str
           Parent catalog for schemas of interest.
         :param include_browse: bool (optional)
@@ -14567,13 +15018,28 @@ class StorageCredentialsAPI:
         return StorageCredentialInfo.from_dict(res)
 
     def list(
-        self, *, max_results: Optional[int] = None, page_token: Optional[str] = None
+        self,
+        *,
+        include_unbound: Optional[bool] = None,
+        max_results: Optional[int] = None,
+        page_token: Optional[str] = None,
     ) -> Iterator[StorageCredentialInfo]:
         """Gets an array of storage credentials (as __StorageCredentialInfo__ objects). The array is limited to
         only those storage credentials the caller has permission to access. If the caller is a metastore
         admin, retrieval of credentials is unrestricted. There is no guarantee of a specific ordering of the
         elements in the array.
 
+        NOTE: we recommend using max_results=0 to use the paginated version of this API. Unpaginated calls
+        will be deprecated soon.
+
+        PAGINATION BEHAVIOR: When using pagination (max_results >= 0), a page may contain zero results while
+        still providing a next_page_token. Clients must continue reading pages until next_page_token is
+        absent, which is the only indication that the end of results has been reached. This behavior follows
+        Google AIP-158 guidelines.
+
+        :param include_unbound: bool (optional)
+          Whether to include credentials not bound to the workspace. Effective only if the user has permission
+          to update the credential–workspace binding.
         :param max_results: int (optional)
           Maximum number of storage credentials to return. If not set, all the storage credentials are
           returned (not recommended). - when set to a value greater than 0, the page length is the minimum of
@@ -14587,6 +15053,8 @@ class StorageCredentialsAPI:
         """
 
         query = {}
+        if include_unbound is not None:
+            query["include_unbound"] = include_unbound
         if max_results is not None:
             query["max_results"] = max_results
         if page_token is not None:
@@ -14822,6 +15290,14 @@ class SystemSchemasAPI:
         """Gets an array of system schemas for a metastore. The caller must be an account admin or a metastore
         admin.
 
+        NOTE: we recommend using max_results=0 to use the paginated version of this API. Unpaginated calls
+        will be deprecated soon.
+
+        PAGINATION BEHAVIOR: When using pagination (max_results >= 0), a page may contain zero results while
+        still providing a next_page_token. Clients must continue reading pages until next_page_token is
+        absent, which is the only indication that the end of results has been reached. This behavior follows
+        Google AIP-158 guidelines.
+
         :param metastore_id: str
           The ID for the metastore in which the system schema resides.
         :param max_results: int (optional)
@@ -15118,6 +15594,14 @@ class TablesAPI:
         catalog and the **USE_SCHEMA** privilege on the parent schema. There is no guarantee of a specific
         ordering of the elements in the array.
 
+        NOTE: we recommend using max_results=0 to use the paginated version of this API. Unpaginated calls
+        will be deprecated soon.
+
+        PAGINATION BEHAVIOR: When using pagination (max_results >= 0), a page may contain zero results while
+        still providing a next_page_token. Clients must continue reading pages until next_page_token is
+        absent, which is the only indication that the end of results has been reached. This behavior follows
+        Google AIP-158 guidelines.
+
         :param catalog_name: str
           Name of parent catalog for tables of interest.
         :param schema_name: str
@@ -15746,9 +16230,11 @@ class WorkspaceBindingsAPI:
         :param securable_name: str
           The name of the securable.
         :param add: List[:class:`WorkspaceBinding`] (optional)
-          List of workspace bindings.
+          List of workspace bindings to add. If a binding for the workspace already exists with a different
+          binding_type, adding it again with a new binding_type will update the existing binding (e.g., from
+          READ_WRITE to READ_ONLY).
         :param remove: List[:class:`WorkspaceBinding`] (optional)
-          List of workspace bindings.
+          List of workspace bindings to remove.
 
         :returns: :class:`UpdateWorkspaceBindingsResponse`
         """