databricks-sdk 0.56.0__py3-none-any.whl → 0.58.0__py3-none-any.whl

databricks/sdk/service/catalog.py

@@ -520,8 +520,10 @@ class AwsIamRole:
 
 @dataclass
 class AwsIamRoleRequest:
+    """The AWS IAM role configuration"""
+
     role_arn: str
-    """The Amazon Resource Name (ARN) of the AWS IAM role for S3 data access."""
+    """The Amazon Resource Name (ARN) of the AWS IAM role used to vend temporary credentials."""
 
     def as_dict(self) -> dict:
         """Serializes the AwsIamRoleRequest into a dictionary suitable for use as a JSON request body."""
@@ -545,11 +547,13 @@ class AwsIamRoleRequest:
 
 @dataclass
 class AwsIamRoleResponse:
+    """The AWS IAM role configuration"""
+
     role_arn: str
-    """The Amazon Resource Name (ARN) of the AWS IAM role for S3 data access."""
+    """The Amazon Resource Name (ARN) of the AWS IAM role used to vend temporary credentials."""
 
     external_id: Optional[str] = None
-    """The external ID used in role assumption to prevent confused deputy problem.."""
+    """The external ID used in role assumption to prevent the confused deputy problem."""
 
     unity_catalog_iam_arn: Optional[str] = None
     """The Amazon Resource Name (ARN) of the AWS IAM user managed by Databricks. This is the identity
@@ -594,7 +598,7 @@ class AwsSqsQueue:
 
     queue_url: Optional[str] = None
     """The AQS queue url in the format https://sqs.{region}.amazonaws.com/{account id}/{queue name}
-    REQUIRED for provided_sqs."""
+    Required for provided_sqs."""
 
     def as_dict(self) -> dict:
         """Serializes the AwsSqsQueue into a dictionary suitable for use as a JSON request body."""
@@ -659,9 +663,7 @@ class AzureManagedIdentity:
     `/subscriptions/{guid}/resourceGroups/{rg-name}/providers/Microsoft.Databricks/accessConnectors/{connector-name}`."""
 
     credential_id: Optional[str] = None
-    """The Databricks internal ID that represents this managed identity. This field is only used to
-    persist the credential_id once it is fetched from the credentials manager - as we only use the
-    protobuf serializer to store credentials, this ID gets persisted to the database. ."""
+    """The Databricks internal ID that represents this managed identity."""
 
     managed_identity_id: Optional[str] = None
     """The Azure resource ID of the managed identity. Use the format,
@@ -704,16 +706,18 @@ class AzureManagedIdentity:
 
 @dataclass
 class AzureManagedIdentityRequest:
+    """The Azure managed identity configuration."""
+
     access_connector_id: str
     """The Azure resource ID of the Azure Databricks Access Connector. Use the format
-    /subscriptions/{guid}/resourceGroups/{rg-name}/providers/Microsoft.Databricks/accessConnectors/{connector-name}."""
+    `/subscriptions/{guid}/resourceGroups/{rg-name}/providers/Microsoft.Databricks/accessConnectors/{connector-name}`."""
 
     managed_identity_id: Optional[str] = None
-    """The Azure resource ID of the managed identity. Use the format
-    /subscriptions/{guid}/resourceGroups/{rg-name}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identity-name}.
+    """The Azure resource ID of the managed identity. Use the format,
+    `/subscriptions/{guid}/resourceGroups/{rg-name}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identity-name}`
     This is only available for user-assgined identities. For system-assigned identities, the
     access_connector_id is used to identify the identity. If this field is not provided, then we
-    assume the AzureManagedIdentity is for a system-assigned identity."""
+    assume the AzureManagedIdentity is using the system-assigned identity."""
 
     def as_dict(self) -> dict:
         """Serializes the AzureManagedIdentityRequest into a dictionary suitable for use as a JSON request body."""
@@ -744,19 +748,21 @@ class AzureManagedIdentityRequest:
 
 @dataclass
 class AzureManagedIdentityResponse:
+    """The Azure managed identity configuration."""
+
     access_connector_id: str
     """The Azure resource ID of the Azure Databricks Access Connector. Use the format
-    /subscriptions/{guid}/resourceGroups/{rg-name}/providers/Microsoft.Databricks/accessConnectors/{connector-name}."""
+    `/subscriptions/{guid}/resourceGroups/{rg-name}/providers/Microsoft.Databricks/accessConnectors/{connector-name}`."""
 
     credential_id: Optional[str] = None
     """The Databricks internal ID that represents this managed identity."""
 
     managed_identity_id: Optional[str] = None
-    """The Azure resource ID of the managed identity. Use the format
-    /subscriptions/{guid}/resourceGroups/{rg-name}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identity-name}.
+    """The Azure resource ID of the managed identity. Use the format,
+    `/subscriptions/{guid}/resourceGroups/{rg-name}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identity-name}`
     This is only available for user-assgined identities. For system-assigned identities, the
     access_connector_id is used to identify the identity. If this field is not provided, then we
-    assume the AzureManagedIdentity is for a system-assigned identity."""
+    assume the AzureManagedIdentity is using the system-assigned identity."""
 
     def as_dict(self) -> dict:
         """Serializes the AzureManagedIdentityResponse into a dictionary suitable for use as a JSON request body."""
@@ -797,15 +803,15 @@ class AzureQueueStorage:
 
     queue_url: Optional[str] = None
     """The AQS queue url in the format https://{storage account}.queue.core.windows.net/{queue name}
-    REQUIRED for provided_aqs."""
+    Required for provided_aqs."""
 
     resource_group: Optional[str] = None
     """The resource group for the queue, event grid subscription, and external location storage
-    account. ONLY REQUIRED for locations with a service principal storage credential"""
+    account. Only required for locations with a service principal storage credential"""
 
     subscription_id: Optional[str] = None
-    """OPTIONAL: The subscription id for the queue, event grid subscription, and external location
-    storage account. REQUIRED for locations with a service principal storage credential"""
+    """Optional subscription id for the queue, event grid subscription, and external location storage
+    account. Required for locations with a service principal storage credential"""
 
     def as_dict(self) -> dict:
         """Serializes the AzureQueueStorage into a dictionary suitable for use as a JSON request body."""
@@ -942,7 +948,6 @@ class CatalogInfo:
     through the BROWSE privilege when include_browse is enabled in the request."""
 
     catalog_type: Optional[CatalogType] = None
-    """The type of the catalog."""
 
     comment: Optional[str] = None
     """User-provided free-form text description."""
@@ -988,10 +993,8 @@ class CatalogInfo:
     A Delta Sharing catalog is a catalog that is based on a Delta share on a remote sharing server."""
 
     provisioning_info: Optional[ProvisioningInfo] = None
-    """Status of an asynchronously provisioned resource."""
 
     securable_type: Optional[SecurableType] = None
-    """The type of Unity Catalog securable."""
 
     share_name: Optional[str] = None
     """The name of the share under the share provider."""
@@ -1157,19 +1160,21 @@ class CatalogType(Enum):
     MANAGED_CATALOG = "MANAGED_CATALOG"
     MANAGED_ONLINE_CATALOG = "MANAGED_ONLINE_CATALOG"
     SYSTEM_CATALOG = "SYSTEM_CATALOG"
-    UNKNOWN_CATALOG_TYPE = "UNKNOWN_CATALOG_TYPE"
 
 
 @dataclass
 class CloudflareApiToken:
+    """The Cloudflare API token configuration. Read more at
+    https://developers.cloudflare.com/r2/api/s3/tokens/"""
+
     access_key_id: str
-    """The Cloudflare access key id of the token."""
+    """The access key ID associated with the API token."""
 
     secret_access_key: str
-    """The secret access token generated for the access key id"""
+    """The secret access token generated for the above access key ID."""
 
     account_id: str
-    """The account id associated with the API token."""
+    """The ID of the account associated with the API token."""
 
     def as_dict(self) -> dict:
         """Serializes the CloudflareApiToken into a dictionary suitable for use as a JSON request body."""
@@ -1350,6 +1355,36 @@ class ColumnMask:
         return cls(function_name=d.get("function_name", None), using_column_names=d.get("using_column_names", None))
 
 
+@dataclass
+class ColumnRelationship:
+    source: Optional[str] = None
+
+    target: Optional[str] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the ColumnRelationship into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.source is not None:
+            body["source"] = self.source
+        if self.target is not None:
+            body["target"] = self.target
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ColumnRelationship into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.source is not None:
+            body["source"] = self.source
+        if self.target is not None:
+            body["target"] = self.target
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ColumnRelationship:
+        """Deserializes the ColumnRelationship from a dictionary."""
+        return cls(source=d.get("source", None), target=d.get("target", None))
+
+
 class ColumnTypeName(Enum):
 
     ARRAY = "ARRAY"
@@ -1378,6 +1413,33 @@ class ColumnTypeName(Enum):
     VARIANT = "VARIANT"
 
 
+@dataclass
+class ConnectionDependency:
+    """A connection that is dependent on a SQL object."""
+
+    connection_name: Optional[str] = None
+    """Full name of the dependent connection, in the form of __connection_name__."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ConnectionDependency into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.connection_name is not None:
+            body["connection_name"] = self.connection_name
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ConnectionDependency into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.connection_name is not None:
+            body["connection_name"] = self.connection_name
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ConnectionDependency:
+        """Deserializes the ConnectionDependency from a dictionary."""
+        return cls(connection_name=d.get("connection_name", None))
+
+
 @dataclass
 class ConnectionInfo:
     comment: Optional[str] = None
@@ -1417,13 +1479,11 @@ class ConnectionInfo:
     """A map of key-value properties attached to the securable."""
 
     provisioning_info: Optional[ProvisioningInfo] = None
-    """Status of an asynchronously provisioned resource."""
 
     read_only: Optional[bool] = None
     """If the connection is read only."""
 
     securable_type: Optional[SecurableType] = None
-    """The type of Unity Catalog securable."""
 
     updated_at: Optional[int] = None
     """Time at which this connection was updated, in epoch milliseconds."""
@@ -1542,7 +1602,7 @@ class ConnectionInfo:
 
 
 class ConnectionType(Enum):
-    """Next Id: 31"""
+    """Next Id: 36"""
 
     BIGQUERY = "BIGQUERY"
     DATABRICKS = "DATABRICKS"
@@ -1773,19 +1833,19 @@ class CreateCredentialRequest:
     metastore."""
 
     aws_iam_role: Optional[AwsIamRole] = None
-    """The AWS IAM role configuration"""
+    """The AWS IAM role configuration."""
 
     azure_managed_identity: Optional[AzureManagedIdentity] = None
     """The Azure managed identity configuration."""
 
     azure_service_principal: Optional[AzureServicePrincipal] = None
-    """The Azure service principal configuration. Only applicable when purpose is **STORAGE**."""
+    """The Azure service principal configuration."""
 
     comment: Optional[str] = None
     """Comment associated with the credential."""
 
     databricks_gcp_service_account: Optional[DatabricksGcpServiceAccount] = None
-    """GCP long-lived credential. Databricks-created Google Cloud Storage service account."""
+    """The Databricks managed GCP service account configuration."""
 
     purpose: Optional[CredentialPurpose] = None
     """Indicates the purpose of the credential."""
@@ -1874,10 +1934,9 @@ class CreateExternalLocation:
     """User-provided free-form text description."""
 
     enable_file_events: Optional[bool] = None
-    """[Create:OPT Update:OPT] Whether to enable file events on this external location."""
+    """Whether to enable file events on this external location."""
 
     encryption_details: Optional[EncryptionDetails] = None
-    """Encryption options that apply to clients connecting to cloud storage."""
 
     fallback: Optional[bool] = None
     """Indicates whether fallback mode is enabled for this external location. When fallback mode is
@@ -1885,7 +1944,7 @@ class CreateExternalLocation:
     sufficient."""
 
     file_event_queue: Optional[FileEventQueue] = None
-    """[Create:OPT Update:OPT] File event queue settings."""
+    """File event queue settings."""
 
     read_only: Optional[bool] = None
     """Indicates whether the external location is read-only."""
@@ -2483,6 +2542,65 @@ class CreateRegisteredModelRequest:
         )
 
 
+@dataclass
+class CreateRequestExternalLineage:
+    source: ExternalLineageObject
+    """Source object of the external lineage relationship."""
+
+    target: ExternalLineageObject
+    """Target object of the external lineage relationship."""
+
+    columns: Optional[List[ColumnRelationship]] = None
+    """List of column relationships between source and target objects."""
+
+    id: Optional[str] = None
+    """Unique identifier of the external lineage relationship."""
+
+    properties: Optional[Dict[str, str]] = None
+    """Key-value properties associated with the external lineage relationship."""
+
+    def as_dict(self) -> dict:
+        """Serializes the CreateRequestExternalLineage into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        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 CreateRequestExternalLineage 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]) -> CreateRequestExternalLineage:
+        """Deserializes the CreateRequestExternalLineage 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 CreateResponse:
     def as_dict(self) -> dict:
@@ -2563,7 +2681,8 @@ class CreateSchema:
 @dataclass
 class CreateStorageCredential:
     name: str
-    """The credential name. The name must be unique within the metastore."""
+    """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."""
@@ -2584,7 +2703,8 @@ class CreateStorageCredential:
     """The Databricks managed GCP service account configuration."""
 
     read_only: Optional[bool] = None
-    """Whether the storage credential is only usable for read operations."""
+    """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."""
@@ -2659,8 +2779,6 @@ class CreateTableConstraint:
     """The full name of the table referenced by the constraint."""
 
     constraint: TableConstraint
-    """A table constraint, as defined by *one* of the following fields being set:
-    __primary_key_constraint__, __foreign_key_constraint__, __named_table_constraint__."""
 
     def as_dict(self) -> dict:
         """Serializes the CreateTableConstraint into a dictionary suitable for use as a JSON request body."""
@@ -2698,11 +2816,6 @@ class CreateVolumeRequestContent:
     """The name of the volume"""
 
     volume_type: VolumeType
-    """The type of the volume. An external volume is located in the specified external location. A
-    managed volume is located in the default location which is specified by the parent schema, or
-    the parent catalog, or the Metastore. [Learn more]
-    
-    [Learn more]: https://docs.databricks.com/aws/en/volumes/managed-vs-external"""
 
     comment: Optional[str] = None
     """The comment attached to the volume"""
@@ -2757,16 +2870,43 @@ class CreateVolumeRequestContent:
         )
 
 
+@dataclass
+class CredentialDependency:
+    """A credential that is dependent on a SQL object."""
+
+    credential_name: Optional[str] = None
+    """Full name of the dependent credential, in the form of __credential_name__."""
+
+    def as_dict(self) -> dict:
+        """Serializes the CredentialDependency into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.credential_name is not None:
+            body["credential_name"] = self.credential_name
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CredentialDependency into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.credential_name is not None:
+            body["credential_name"] = self.credential_name
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> CredentialDependency:
+        """Deserializes the CredentialDependency from a dictionary."""
+        return cls(credential_name=d.get("credential_name", None))
+
+
 @dataclass
 class CredentialInfo:
     aws_iam_role: Optional[AwsIamRole] = None
-    """The AWS IAM role configuration"""
+    """The AWS IAM role configuration."""
 
     azure_managed_identity: Optional[AzureManagedIdentity] = None
     """The Azure managed identity configuration."""
 
     azure_service_principal: Optional[AzureServicePrincipal] = None
-    """The Azure service principal configuration. Only applicable when purpose is **STORAGE**."""
+    """The Azure service principal configuration."""
 
     comment: Optional[str] = None
     """Comment associated with the credential."""
@@ -2778,7 +2918,7 @@ class CredentialInfo:
     """Username of credential creator."""
 
     databricks_gcp_service_account: Optional[DatabricksGcpServiceAccount] = None
-    """GCP long-lived credential. Databricks-created Google Cloud Storage service account."""
+    """The Databricks managed GCP service account configuration."""
 
     full_name: Optional[str] = None
     """The full name of the credential."""
@@ -2930,8 +3070,9 @@ class CredentialPurpose(Enum):
 
 
 class CredentialType(Enum):
-    """Next Id: 12"""
+    """Next Id: 13"""
 
+    ANY_STATIC_CREDENTIAL = "ANY_STATIC_CREDENTIAL"
     BEARER_TOKEN = "BEARER_TOKEN"
     OAUTH_ACCESS_TOKEN = "OAUTH_ACCESS_TOKEN"
     OAUTH_M2M = "OAUTH_M2M"
@@ -2985,21 +3126,28 @@ class DataSourceFormat(Enum):
     BIGQUERY_FORMAT = "BIGQUERY_FORMAT"
     CSV = "CSV"
     DATABRICKS_FORMAT = "DATABRICKS_FORMAT"
+    DATABRICKS_ROW_STORE_FORMAT = "DATABRICKS_ROW_STORE_FORMAT"
     DELTA = "DELTA"
     DELTASHARING = "DELTASHARING"
-    HIVE_CUSTOM = "HIVE_CUSTOM"
-    HIVE_SERDE = "HIVE_SERDE"
+    DELTA_UNIFORM_HUDI = "DELTA_UNIFORM_HUDI"
+    DELTA_UNIFORM_ICEBERG = "DELTA_UNIFORM_ICEBERG"
+    HIVE = "HIVE"
+    ICEBERG = "ICEBERG"
     JSON = "JSON"
+    MONGODB_FORMAT = "MONGODB_FORMAT"
     MYSQL_FORMAT = "MYSQL_FORMAT"
     NETSUITE_FORMAT = "NETSUITE_FORMAT"
+    ORACLE_FORMAT = "ORACLE_FORMAT"
     ORC = "ORC"
     PARQUET = "PARQUET"
     POSTGRESQL_FORMAT = "POSTGRESQL_FORMAT"
     REDSHIFT_FORMAT = "REDSHIFT_FORMAT"
+    SALESFORCE_DATA_CLOUD_FORMAT = "SALESFORCE_DATA_CLOUD_FORMAT"
     SALESFORCE_FORMAT = "SALESFORCE_FORMAT"
     SNOWFLAKE_FORMAT = "SNOWFLAKE_FORMAT"
     SQLDW_FORMAT = "SQLDW_FORMAT"
     SQLSERVER_FORMAT = "SQLSERVER_FORMAT"
+    TERADATA_FORMAT = "TERADATA_FORMAT"
     TEXT = "TEXT"
     UNITY_CATALOG = "UNITY_CATALOG"
     VECTOR_INDEX_FORMAT = "VECTOR_INDEX_FORMAT"
@@ -3011,9 +3159,7 @@ class DatabricksGcpServiceAccount:
     """GCP long-lived credential. Databricks-created Google Cloud Storage service account."""
 
     credential_id: Optional[str] = None
-    """The Databricks internal ID that represents this managed identity. This field is only used to
-    persist the credential_id once it is fetched from the credentials manager - as we only use the
-    protobuf serializer to store credentials, this ID gets persisted to the database"""
+    """The Databricks internal ID that represents this managed identity."""
 
     email: Optional[str] = None
     """The email of the service account."""
@@ -3055,6 +3201,8 @@ class DatabricksGcpServiceAccount:
 
 @dataclass
 class DatabricksGcpServiceAccountRequest:
+    """GCP long-lived credential. Databricks-created Google Cloud Storage service account."""
+
     def as_dict(self) -> dict:
         """Serializes the DatabricksGcpServiceAccountRequest into a dictionary suitable for use as a JSON request body."""
         body = {}
@@ -3073,11 +3221,13 @@ class DatabricksGcpServiceAccountRequest:
 
 @dataclass
 class DatabricksGcpServiceAccountResponse:
+    """GCP long-lived credential. Databricks-created Google Cloud Storage service account."""
+
     credential_id: Optional[str] = None
-    """The Databricks internal ID that represents this service account. This is an output-only field."""
+    """The Databricks internal ID that represents this managed identity."""
 
     email: Optional[str] = None
-    """The email of the service account. This is an output-only field."""
+    """The email of the service account."""
 
     def as_dict(self) -> dict:
         """Serializes the DatabricksGcpServiceAccountResponse into a dictionary suitable for use as a JSON request body."""
@@ -3139,6 +3289,49 @@ class DeleteCredentialResponse:
         return cls()
 
 
+@dataclass
+class DeleteRequestExternalLineage:
+    source: ExternalLineageObject
+    """Source object of the external lineage relationship."""
+
+    target: ExternalLineageObject
+    """Target object of the external lineage relationship."""
+
+    id: Optional[str] = None
+    """Unique identifier of the external lineage relationship."""
+
+    def as_dict(self) -> dict:
+        """Serializes the DeleteRequestExternalLineage into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.id is not None:
+            body["id"] = self.id
+        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 DeleteRequestExternalLineage into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.id is not None:
+            body["id"] = self.id
+        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]) -> DeleteRequestExternalLineage:
+        """Deserializes the DeleteRequestExternalLineage from a dictionary."""
+        return cls(
+            id=d.get("id", None),
+            source=_from_dict(d, "source", ExternalLineageObject),
+            target=_from_dict(d, "target", ExternalLineageObject),
+        )
+
+
 @dataclass
 class DeleteResponse:
     def as_dict(self) -> dict:
@@ -3193,18 +3386,24 @@ class DeltaSharingScopeEnum(Enum):
 
 @dataclass
 class Dependency:
-    """A dependency of a SQL object. Either the __table__ field or the __function__ field must be
-    defined."""
+    """A dependency of a SQL object. One of the following fields must be defined: __table__,
+    __function__, __connection__, or __credential__."""
+
+    connection: Optional[ConnectionDependency] = None
+
+    credential: Optional[CredentialDependency] = None
 
     function: Optional[FunctionDependency] = None
-    """A function that is dependent on a SQL object."""
 
     table: Optional[TableDependency] = None
-    """A table that is dependent on a SQL object."""
 
     def as_dict(self) -> dict:
         """Serializes the Dependency into a dictionary suitable for use as a JSON request body."""
         body = {}
+        if self.connection:
+            body["connection"] = self.connection.as_dict()
+        if self.credential:
+            body["credential"] = self.credential.as_dict()
         if self.function:
             body["function"] = self.function.as_dict()
         if self.table:
@@ -3214,6 +3413,10 @@ class Dependency:
     def as_shallow_dict(self) -> dict:
         """Serializes the Dependency into a shallow dictionary of its immediate attributes."""
         body = {}
+        if self.connection:
+            body["connection"] = self.connection
+        if self.credential:
+            body["credential"] = self.credential
         if self.function:
             body["function"] = self.function
         if self.table:
@@ -3224,7 +3427,10 @@ class Dependency:
     def from_dict(cls, d: Dict[str, Any]) -> Dependency:
         """Deserializes the Dependency from a dictionary."""
         return cls(
-            function=_from_dict(d, "function", FunctionDependency), table=_from_dict(d, "table", TableDependency)
+            connection=_from_dict(d, "connection", ConnectionDependency),
+            credential=_from_dict(d, "credential", CredentialDependency),
+            function=_from_dict(d, "function", FunctionDependency),
+            table=_from_dict(d, "table", TableDependency),
         )
 
 
@@ -3535,70 +3741,607 @@ class EncryptionDetails:
 
 
 @dataclass
-class ExternalLocationInfo:
-    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."""
+class ExternalLineageExternalMetadata:
+    name: Optional[str] = None
 
-    comment: Optional[str] = None
-    """User-provided free-form text description."""
+    def as_dict(self) -> dict:
+        """Serializes the ExternalLineageExternalMetadata into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.name is not None:
+            body["name"] = self.name
+        return body
 
-    created_at: Optional[int] = None
-    """Time at which this external location was created, in epoch milliseconds."""
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ExternalLineageExternalMetadata into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.name is not None:
+            body["name"] = self.name
+        return body
 
-    created_by: Optional[str] = None
-    """Username of external location creator."""
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ExternalLineageExternalMetadata:
+        """Deserializes the ExternalLineageExternalMetadata from a dictionary."""
+        return cls(name=d.get("name", None))
 
-    credential_id: Optional[str] = None
-    """Unique ID of the location's storage credential."""
 
-    credential_name: Optional[str] = None
-    """Name of the storage credential used with this location."""
+@dataclass
+class ExternalLineageExternalMetadataInfo:
+    """Represents the external metadata object in the lineage event."""
 
-    enable_file_events: Optional[bool] = None
-    """[Create:OPT Update:OPT] Whether to enable file events on this external location."""
+    entity_type: Optional[str] = None
+    """Type of entity represented by the external metadata object."""
 
-    encryption_details: Optional[EncryptionDetails] = None
-    """Encryption options that apply to clients connecting to cloud storage."""
+    event_time: Optional[str] = None
+    """Timestamp of the lineage event."""
 
-    fallback: Optional[bool] = None
-    """Indicates whether fallback mode is enabled for this external location. When fallback mode is
-    enabled, the access to the location falls back to cluster credentials if UC credentials are not
-    sufficient."""
+    name: Optional[str] = None
+    """Name of the external metadata object."""
 
-    file_event_queue: Optional[FileEventQueue] = None
-    """[Create:OPT Update:OPT] File event queue settings."""
+    system_type: Optional[SystemType] = None
+    """Type of external system."""
 
-    isolation_mode: Optional[IsolationMode] = None
+    def as_dict(self) -> dict:
+        """Serializes the ExternalLineageExternalMetadataInfo into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.entity_type is not None:
+            body["entity_type"] = self.entity_type
+        if self.event_time is not None:
+            body["event_time"] = self.event_time
+        if self.name is not None:
+            body["name"] = self.name
+        if self.system_type is not None:
+            body["system_type"] = self.system_type.value
+        return body
 
-    metastore_id: Optional[str] = None
-    """Unique identifier of metastore hosting the external location."""
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ExternalLineageExternalMetadataInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.entity_type is not None:
+            body["entity_type"] = self.entity_type
+        if self.event_time is not None:
+            body["event_time"] = self.event_time
+        if self.name is not None:
+            body["name"] = self.name
+        if self.system_type is not None:
+            body["system_type"] = self.system_type
+        return body
 
-    name: Optional[str] = None
-    """Name of the external location."""
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ExternalLineageExternalMetadataInfo:
+        """Deserializes the ExternalLineageExternalMetadataInfo from a dictionary."""
+        return cls(
+            entity_type=d.get("entity_type", None),
+            event_time=d.get("event_time", None),
+            name=d.get("name", None),
+            system_type=_enum(d, "system_type", SystemType),
+        )
 
-    owner: Optional[str] = None
-    """The owner of the external location."""
 
-    read_only: Optional[bool] = None
-    """Indicates whether the external location is read-only."""
+@dataclass
+class ExternalLineageFileInfo:
+    """Represents the path information in the lineage event."""
 
-    updated_at: Optional[int] = None
-    """Time at which external location this was last modified, in epoch milliseconds."""
+    event_time: Optional[str] = None
+    """Timestamp of the lineage event."""
 
-    updated_by: Optional[str] = None
-    """Username of user who last modified the external location."""
+    path: Optional[str] = None
+    """URL of the path."""
 
-    url: Optional[str] = None
-    """Path URL of the external location."""
+    securable_name: Optional[str] = None
+    """The full name of the securable on the path."""
+
+    securable_type: Optional[str] = None
+    """The securable type of the securable on the path."""
+
+    storage_location: Optional[str] = None
+    """The storage location associated with securable on the path."""
 
     def as_dict(self) -> dict:
-        """Serializes the ExternalLocationInfo into a dictionary suitable for use as a JSON request body."""
+        """Serializes the ExternalLineageFileInfo into a dictionary suitable for use as a JSON request body."""
         body = {}
-        if self.browse_only is not None:
-            body["browse_only"] = self.browse_only
-        if self.comment is not None:
-            body["comment"] = self.comment
+        if self.event_time is not None:
+            body["event_time"] = self.event_time
+        if self.path is not None:
+            body["path"] = self.path
+        if self.securable_name is not None:
+            body["securable_name"] = self.securable_name
+        if self.securable_type is not None:
+            body["securable_type"] = self.securable_type
+        if self.storage_location is not None:
+            body["storage_location"] = self.storage_location
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ExternalLineageFileInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.event_time is not None:
+            body["event_time"] = self.event_time
+        if self.path is not None:
+            body["path"] = self.path
+        if self.securable_name is not None:
+            body["securable_name"] = self.securable_name
+        if self.securable_type is not None:
+            body["securable_type"] = self.securable_type
+        if self.storage_location is not None:
+            body["storage_location"] = self.storage_location
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ExternalLineageFileInfo:
+        """Deserializes the ExternalLineageFileInfo from a dictionary."""
+        return cls(
+            event_time=d.get("event_time", None),
+            path=d.get("path", None),
+            securable_name=d.get("securable_name", None),
+            securable_type=d.get("securable_type", None),
+            storage_location=d.get("storage_location", None),
+        )
+
+
+@dataclass
+class ExternalLineageInfo:
+    """Lineage response containing lineage information of a data asset."""
+
+    external_lineage_info: Optional[ExternalLineageRelationshipInfo] = None
+    """Information about the edge metadata of the external lineage relationship."""
+
+    external_metadata_info: Optional[ExternalLineageExternalMetadataInfo] = None
+    """Information about external metadata involved in the lineage relationship."""
+
+    file_info: Optional[ExternalLineageFileInfo] = None
+    """Information about the file involved in the lineage relationship."""
+
+    model_info: Optional[ExternalLineageModelVersionInfo] = None
+    """Information about the model version involved in the lineage relationship."""
+
+    table_info: Optional[ExternalLineageTableInfo] = None
+    """Information about the table involved in the lineage relationship."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ExternalLineageInfo into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.external_lineage_info:
+            body["external_lineage_info"] = self.external_lineage_info.as_dict()
+        if self.external_metadata_info:
+            body["external_metadata_info"] = self.external_metadata_info.as_dict()
+        if self.file_info:
+            body["file_info"] = self.file_info.as_dict()
+        if self.model_info:
+            body["model_info"] = self.model_info.as_dict()
+        if self.table_info:
+            body["table_info"] = self.table_info.as_dict()
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ExternalLineageInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.external_lineage_info:
+            body["external_lineage_info"] = self.external_lineage_info
+        if self.external_metadata_info:
+            body["external_metadata_info"] = self.external_metadata_info
+        if self.file_info:
+            body["file_info"] = self.file_info
+        if self.model_info:
+            body["model_info"] = self.model_info
+        if self.table_info:
+            body["table_info"] = self.table_info
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ExternalLineageInfo:
+        """Deserializes the ExternalLineageInfo from a dictionary."""
+        return cls(
+            external_lineage_info=_from_dict(d, "external_lineage_info", ExternalLineageRelationshipInfo),
+            external_metadata_info=_from_dict(d, "external_metadata_info", ExternalLineageExternalMetadataInfo),
+            file_info=_from_dict(d, "file_info", ExternalLineageFileInfo),
+            model_info=_from_dict(d, "model_info", ExternalLineageModelVersionInfo),
+            table_info=_from_dict(d, "table_info", ExternalLineageTableInfo),
+        )
+
+
+@dataclass
+class ExternalLineageModelVersion:
+    name: Optional[str] = None
+
+    version: Optional[str] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the ExternalLineageModelVersion into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.name is not None:
+            body["name"] = self.name
+        if self.version is not None:
+            body["version"] = self.version
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ExternalLineageModelVersion into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.name is not None:
+            body["name"] = self.name
+        if self.version is not None:
+            body["version"] = self.version
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ExternalLineageModelVersion:
+        """Deserializes the ExternalLineageModelVersion from a dictionary."""
+        return cls(name=d.get("name", None), version=d.get("version", None))
+
+
+@dataclass
+class ExternalLineageModelVersionInfo:
+    """Represents the model version information in the lineage event."""
+
+    event_time: Optional[str] = None
+    """Timestamp of the lineage event."""
+
+    model_name: Optional[str] = None
+    """Name of the model."""
+
+    version: Optional[int] = None
+    """Version number of the model."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ExternalLineageModelVersionInfo into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.event_time is not None:
+            body["event_time"] = self.event_time
+        if self.model_name is not None:
+            body["model_name"] = self.model_name
+        if self.version is not None:
+            body["version"] = self.version
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ExternalLineageModelVersionInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.event_time is not None:
+            body["event_time"] = self.event_time
+        if self.model_name is not None:
+            body["model_name"] = self.model_name
+        if self.version is not None:
+            body["version"] = self.version
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ExternalLineageModelVersionInfo:
+        """Deserializes the ExternalLineageModelVersionInfo from a dictionary."""
+        return cls(
+            event_time=d.get("event_time", None), model_name=d.get("model_name", None), version=d.get("version", None)
+        )
+
+
+@dataclass
+class ExternalLineageObject:
+    external_metadata: Optional[ExternalLineageExternalMetadata] = None
+
+    model_version: Optional[ExternalLineageModelVersion] = None
+
+    path: Optional[ExternalLineagePath] = None
+
+    table: Optional[ExternalLineageTable] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the ExternalLineageObject into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.external_metadata:
+            body["external_metadata"] = self.external_metadata.as_dict()
+        if self.model_version:
+            body["model_version"] = self.model_version.as_dict()
+        if self.path:
+            body["path"] = self.path.as_dict()
+        if self.table:
+            body["table"] = self.table.as_dict()
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ExternalLineageObject into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.external_metadata:
+            body["external_metadata"] = self.external_metadata
+        if self.model_version:
+            body["model_version"] = self.model_version
+        if self.path:
+            body["path"] = self.path
+        if self.table:
+            body["table"] = self.table
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ExternalLineageObject:
+        """Deserializes the ExternalLineageObject from a dictionary."""
+        return cls(
+            external_metadata=_from_dict(d, "external_metadata", ExternalLineageExternalMetadata),
+            model_version=_from_dict(d, "model_version", ExternalLineageModelVersion),
+            path=_from_dict(d, "path", ExternalLineagePath),
+            table=_from_dict(d, "table", ExternalLineageTable),
+        )
+
+
+@dataclass
+class ExternalLineagePath:
+    url: Optional[str] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the ExternalLineagePath into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.url is not None:
+            body["url"] = self.url
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ExternalLineagePath into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.url is not None:
+            body["url"] = self.url
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ExternalLineagePath:
+        """Deserializes the ExternalLineagePath from a dictionary."""
+        return cls(url=d.get("url", None))
+
+
+@dataclass
+class ExternalLineageRelationship:
+    source: ExternalLineageObject
+    """Source object of the external lineage relationship."""
+
+    target: ExternalLineageObject
+    """Target object of the external lineage relationship."""
+
+    columns: Optional[List[ColumnRelationship]] = None
+    """List of column relationships between source and target objects."""
+
+    id: Optional[str] = None
+    """Unique identifier of the external lineage relationship."""
+
+    properties: Optional[Dict[str, str]] = None
+    """Key-value properties associated with the external lineage relationship."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ExternalLineageRelationship into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        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 ExternalLineageRelationship 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]) -> ExternalLineageRelationship:
+        """Deserializes the ExternalLineageRelationship 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 ExternalLineageRelationshipInfo:
+    source: ExternalLineageObject
+    """Source object of the external lineage relationship."""
+
+    target: ExternalLineageObject
+    """Target object of the external lineage relationship."""
+
+    columns: Optional[List[ColumnRelationship]] = None
+    """List of column relationships between source and target objects."""
+
+    id: Optional[str] = None
+    """Unique identifier of the external lineage relationship."""
+
+    properties: Optional[Dict[str, str]] = None
+    """Key-value properties associated with the external lineage relationship."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ExternalLineageRelationshipInfo into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        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 ExternalLineageRelationshipInfo 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]) -> ExternalLineageRelationshipInfo:
+        """Deserializes the ExternalLineageRelationshipInfo 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 ExternalLineageTable:
+    name: Optional[str] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the ExternalLineageTable into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.name is not None:
+            body["name"] = self.name
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ExternalLineageTable into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.name is not None:
+            body["name"] = self.name
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ExternalLineageTable:
+        """Deserializes the ExternalLineageTable from a dictionary."""
+        return cls(name=d.get("name", None))
+
+
+@dataclass
+class ExternalLineageTableInfo:
+    """Represents the table information in the lineage event."""
+
+    catalog_name: Optional[str] = None
+    """Name of Catalog."""
+
+    event_time: Optional[str] = None
+    """Timestamp of the lineage event."""
+
+    name: Optional[str] = None
+    """Name of Table."""
+
+    schema_name: Optional[str] = None
+    """Name of Schema."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ExternalLineageTableInfo into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.catalog_name is not None:
+            body["catalog_name"] = self.catalog_name
+        if self.event_time is not None:
+            body["event_time"] = self.event_time
+        if self.name is not None:
+            body["name"] = self.name
+        if self.schema_name is not None:
+            body["schema_name"] = self.schema_name
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ExternalLineageTableInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.catalog_name is not None:
+            body["catalog_name"] = self.catalog_name
+        if self.event_time is not None:
+            body["event_time"] = self.event_time
+        if self.name is not None:
+            body["name"] = self.name
+        if self.schema_name is not None:
+            body["schema_name"] = self.schema_name
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ExternalLineageTableInfo:
+        """Deserializes the ExternalLineageTableInfo from a dictionary."""
+        return cls(
+            catalog_name=d.get("catalog_name", None),
+            event_time=d.get("event_time", None),
+            name=d.get("name", None),
+            schema_name=d.get("schema_name", None),
+        )
+
+
+@dataclass
+class ExternalLocationInfo:
+    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."""
+
+    comment: Optional[str] = None
+    """User-provided free-form text description."""
+
+    created_at: Optional[int] = None
+    """Time at which this external location was created, in epoch milliseconds."""
+
+    created_by: Optional[str] = None
+    """Username of external location creator."""
+
+    credential_id: Optional[str] = None
+    """Unique ID of the location's storage credential."""
+
+    credential_name: Optional[str] = None
+    """Name of the storage credential used with this location."""
+
+    enable_file_events: Optional[bool] = None
+    """Whether to enable file events on this external location."""
+
+    encryption_details: Optional[EncryptionDetails] = None
+
+    fallback: Optional[bool] = None
+    """Indicates whether fallback mode is enabled for this external location. When fallback mode is
+    enabled, the access to the location falls back to cluster credentials if UC credentials are not
+    sufficient."""
+
+    file_event_queue: Optional[FileEventQueue] = None
+    """File event queue settings."""
+
+    isolation_mode: Optional[IsolationMode] = None
+
+    metastore_id: Optional[str] = None
+    """Unique identifier of metastore hosting the external location."""
+
+    name: Optional[str] = None
+    """Name of the external location."""
+
+    owner: Optional[str] = None
+    """The owner of the external location."""
+
+    read_only: Optional[bool] = None
+    """Indicates whether the external location is read-only."""
+
+    updated_at: Optional[int] = None
+    """Time at which external location this was last modified, in epoch milliseconds."""
+
+    updated_by: Optional[str] = None
+    """Username of user who last modified the external location."""
+
+    url: Optional[str] = None
+    """Path URL of the external location."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ExternalLocationInfo into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.browse_only is not None:
+            body["browse_only"] = self.browse_only
+        if self.comment is not None:
+            body["comment"] = self.comment
         if self.created_at is not None:
             body["created_at"] = self.created_at
         if self.created_by is not None:
@@ -3692,8 +4435,139 @@ class ExternalLocationInfo:
             metastore_id=d.get("metastore_id", None),
             name=d.get("name", None),
             owner=d.get("owner", None),
-            read_only=d.get("read_only", None),
-            updated_at=d.get("updated_at", None),
+            read_only=d.get("read_only", None),
+            updated_at=d.get("updated_at", None),
+            updated_by=d.get("updated_by", None),
+            url=d.get("url", None),
+        )
+
+
+@dataclass
+class ExternalMetadata:
+    name: str
+    """Name of the external metadata object."""
+
+    system_type: SystemType
+    """Type of external system."""
+
+    entity_type: str
+    """Type of entity within the external system."""
+
+    columns: Optional[List[str]] = None
+    """List of columns associated with the external metadata object."""
+
+    create_time: Optional[str] = None
+    """Time at which this external metadata object was created."""
+
+    created_by: Optional[str] = None
+    """Username of external metadata object creator."""
+
+    description: Optional[str] = None
+    """User-provided free-form text description."""
+
+    id: Optional[str] = None
+    """Unique identifier of the external metadata object."""
+
+    metastore_id: Optional[str] = None
+    """Unique identifier of parent metastore."""
+
+    owner: Optional[str] = None
+    """Owner of the external metadata object."""
+
+    properties: Optional[Dict[str, str]] = None
+    """A map of key-value properties attached to the external metadata object."""
+
+    update_time: Optional[str] = None
+    """Time at which this external metadata object was last modified."""
+
+    updated_by: Optional[str] = None
+    """Username of user who last modified external metadata object."""
+
+    url: Optional[str] = None
+    """URL associated with the external metadata object."""
+
+    def as_dict(self) -> dict:
+        """Serializes the ExternalMetadata into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.columns:
+            body["columns"] = [v for v in self.columns]
+        if self.create_time is not None:
+            body["create_time"] = self.create_time
+        if self.created_by is not None:
+            body["created_by"] = self.created_by
+        if self.description is not None:
+            body["description"] = self.description
+        if self.entity_type is not None:
+            body["entity_type"] = self.entity_type
+        if self.id is not None:
+            body["id"] = self.id
+        if self.metastore_id is not None:
+            body["metastore_id"] = self.metastore_id
+        if self.name is not None:
+            body["name"] = self.name
+        if self.owner is not None:
+            body["owner"] = self.owner
+        if self.properties:
+            body["properties"] = self.properties
+        if self.system_type is not None:
+            body["system_type"] = self.system_type.value
+        if self.update_time is not None:
+            body["update_time"] = self.update_time
+        if self.updated_by is not None:
+            body["updated_by"] = self.updated_by
+        if self.url is not None:
+            body["url"] = self.url
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ExternalMetadata into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.columns:
+            body["columns"] = self.columns
+        if self.create_time is not None:
+            body["create_time"] = self.create_time
+        if self.created_by is not None:
+            body["created_by"] = self.created_by
+        if self.description is not None:
+            body["description"] = self.description
+        if self.entity_type is not None:
+            body["entity_type"] = self.entity_type
+        if self.id is not None:
+            body["id"] = self.id
+        if self.metastore_id is not None:
+            body["metastore_id"] = self.metastore_id
+        if self.name is not None:
+            body["name"] = self.name
+        if self.owner is not None:
+            body["owner"] = self.owner
+        if self.properties:
+            body["properties"] = self.properties
+        if self.system_type is not None:
+            body["system_type"] = self.system_type
+        if self.update_time is not None:
+            body["update_time"] = self.update_time
+        if self.updated_by is not None:
+            body["updated_by"] = self.updated_by
+        if self.url is not None:
+            body["url"] = self.url
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ExternalMetadata:
+        """Deserializes the ExternalMetadata from a dictionary."""
+        return cls(
+            columns=d.get("columns", None),
+            create_time=d.get("create_time", None),
+            created_by=d.get("created_by", None),
+            description=d.get("description", None),
+            entity_type=d.get("entity_type", None),
+            id=d.get("id", None),
+            metastore_id=d.get("metastore_id", None),
+            name=d.get("name", None),
+            owner=d.get("owner", None),
+            properties=d.get("properties", None),
+            system_type=_enum(d, "system_type", SystemType),
+            update_time=d.get("update_time", None),
             updated_by=d.get("updated_by", None),
             url=d.get("url", None),
         )
@@ -3815,6 +4689,9 @@ class ForeignKeyConstraint:
     parent_columns: List[str]
     """Column names for this constraint."""
 
+    rely: Optional[bool] = None
+    """True if the constraint is RELY, false or unset if NORELY."""
+
     def as_dict(self) -> dict:
         """Serializes the ForeignKeyConstraint into a dictionary suitable for use as a JSON request body."""
         body = {}
@@ -3826,6 +4703,8 @@ class ForeignKeyConstraint:
             body["parent_columns"] = [v for v in self.parent_columns]
         if self.parent_table is not None:
             body["parent_table"] = self.parent_table
+        if self.rely is not None:
+            body["rely"] = self.rely
         return body
 
     def as_shallow_dict(self) -> dict:
@@ -3839,6 +4718,8 @@ class ForeignKeyConstraint:
             body["parent_columns"] = self.parent_columns
         if self.parent_table is not None:
             body["parent_table"] = self.parent_table
+        if self.rely is not None:
+            body["rely"] = self.rely
         return body
 
     @classmethod
@@ -3849,6 +4730,7 @@ class ForeignKeyConstraint:
             name=d.get("name", None),
             parent_columns=d.get("parent_columns", None),
             parent_table=d.get("parent_table", None),
+            rely=d.get("rely", None),
         )
 
 
@@ -4192,10 +5074,8 @@ class FunctionParameterInfo:
     """Default value of the parameter."""
 
     parameter_mode: Optional[FunctionParameterMode] = None
-    """The mode of the function parameter."""
 
     parameter_type: Optional[FunctionParameterType] = None
-    """The type of function parameter."""
 
     type_interval_type: Optional[str] = None
     """Format of IntervalType."""
@@ -4358,7 +5238,7 @@ class GcpPubsub:
 
     subscription_name: Optional[str] = None
     """The Pub/Sub subscription name in the format projects/{project}/subscriptions/{subscription name}
-    REQUIRED for provided_pubsub."""
+    Required for provided_pubsub."""
 
     def as_dict(self) -> dict:
         """Serializes the GcpPubsub into a dictionary suitable for use as a JSON request body."""
@@ -4450,10 +5330,8 @@ class GenerateTemporaryServiceCredentialRequest:
     """The name of the service credential used to generate a temporary credential"""
 
     azure_options: Optional[GenerateTemporaryServiceCredentialAzureOptions] = None
-    """The Azure cloud options to customize the requested temporary credential"""
 
     gcp_options: Optional[GenerateTemporaryServiceCredentialGcpOptions] = None
-    """The GCP cloud options to customize the requested temporary credential"""
 
     def as_dict(self) -> dict:
         """Serializes the GenerateTemporaryServiceCredentialRequest into a dictionary suitable for use as a JSON request body."""
@@ -4524,29 +5402,18 @@ class GenerateTemporaryTableCredentialRequest:
 @dataclass
 class GenerateTemporaryTableCredentialResponse:
     aws_temp_credentials: Optional[AwsCredentials] = None
-    """AWS temporary credentials for API authentication. Read more at
-    https://docs.aws.amazon.com/STS/latest/APIReference/API_Credentials.html."""
 
     azure_aad: Optional[AzureActiveDirectoryToken] = None
-    """Azure Active Directory token, essentially the Oauth token for Azure Service Principal or Managed
-    Identity. Read more at
-    https://learn.microsoft.com/en-us/azure/databricks/dev-tools/api/latest/aad/service-prin-aad-token"""
 
     azure_user_delegation_sas: Optional[AzureUserDelegationSas] = None
-    """Azure temporary credentials for API authentication. Read more at
-    https://docs.microsoft.com/en-us/rest/api/storageservices/create-user-delegation-sas"""
 
     expiration_time: Optional[int] = None
     """Server time when the credential will expire, in epoch milliseconds. The API client is advised to
     cache the credential given this expiration time."""
 
     gcp_oauth_token: Optional[GcpOauthToken] = None
-    """GCP temporary credentials for API authentication. Read more at
-    https://developers.google.com/identity/protocols/oauth2/service-account"""
 
     r2_temp_credentials: Optional[R2Credentials] = None
-    """R2 temporary credentials for API authentication. Read more at
-    https://developers.cloudflare.com/r2/api/s3/tokens/."""
 
     url: Optional[str] = None
     """The URL of the storage path accessible by the temporary credential."""
@@ -4908,6 +5775,12 @@ class IsolationMode(Enum):
     ISOLATION_MODE_OPEN = "ISOLATION_MODE_OPEN"
 
 
+class LineageDirection(Enum):
+
+    DOWNSTREAM = "DOWNSTREAM"
+    UPSTREAM = "UPSTREAM"
+
+
 @dataclass
 class ListAccountMetastoreAssignmentsResponse:
     """The list of workspaces to which the given metastore is assigned."""
@@ -5061,6 +5934,39 @@ class ListCredentialsResponse:
         )
 
 
+@dataclass
+class ListExternalLineageRelationshipsResponse:
+    external_lineage_relationships: Optional[List[ExternalLineageInfo]] = None
+
+    next_page_token: Optional[str] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the ListExternalLineageRelationshipsResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.external_lineage_relationships:
+            body["external_lineage_relationships"] = [v.as_dict() for v in self.external_lineage_relationships]
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListExternalLineageRelationshipsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.external_lineage_relationships:
+            body["external_lineage_relationships"] = self.external_lineage_relationships
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ListExternalLineageRelationshipsResponse:
+        """Deserializes the ListExternalLineageRelationshipsResponse from a dictionary."""
+        return cls(
+            external_lineage_relationships=_repeated_dict(d, "external_lineage_relationships", ExternalLineageInfo),
+            next_page_token=d.get("next_page_token", None),
+        )
+
+
 @dataclass
 class ListExternalLocationsResponse:
     external_locations: Optional[List[ExternalLocationInfo]] = None
@@ -5097,6 +6003,39 @@ class ListExternalLocationsResponse:
         )
 
 
+@dataclass
+class ListExternalMetadataResponse:
+    external_metadata: Optional[List[ExternalMetadata]] = None
+
+    next_page_token: Optional[str] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the ListExternalMetadataResponse into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.external_metadata:
+            body["external_metadata"] = [v.as_dict() for v in self.external_metadata]
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListExternalMetadataResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.external_metadata:
+            body["external_metadata"] = self.external_metadata
+        if self.next_page_token is not None:
+            body["next_page_token"] = self.next_page_token
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> ListExternalMetadataResponse:
+        """Deserializes the ListExternalMetadataResponse from a dictionary."""
+        return cls(
+            external_metadata=_repeated_dict(d, "external_metadata", ExternalMetadata),
+            next_page_token=d.get("next_page_token", None),
+        )
+
+
 @dataclass
 class ListFunctionsResponse:
     functions: Optional[List[FunctionInfo]] = None
@@ -6085,7 +7024,6 @@ class MonitorInfo:
     """The full name of the table to monitor. Format: __catalog_name__.__schema_name__.__table_name__."""
 
     status: MonitorInfoStatus
-    """The status of the monitor."""
 
     monitor_version: str
     """The version of the monitor config (e.g. 1,2,3). If negative, the monitor may be corrupted."""
@@ -6771,26 +7709,18 @@ class OnlineTableStatus:
     """Status of an online table."""
 
     continuous_update_status: Optional[ContinuousUpdateStatus] = None
-    """Detailed status of an online table. Shown if the online table is in the ONLINE_CONTINUOUS_UPDATE
-    or the ONLINE_UPDATING_PIPELINE_RESOURCES state."""
 
     detailed_state: Optional[OnlineTableState] = None
     """The state of the online table."""
 
     failed_status: Optional[FailedStatus] = None
-    """Detailed status of an online table. Shown if the online table is in the OFFLINE_FAILED or the
-    ONLINE_PIPELINE_FAILED state."""
 
     message: Optional[str] = None
     """A text description of the current state of the online table."""
 
     provisioning_status: Optional[ProvisioningStatus] = None
-    """Detailed status of an online table. Shown if the online table is in the
-    PROVISIONING_PIPELINE_RESOURCES or the PROVISIONING_INITIAL_SNAPSHOT state."""
 
     triggered_update_status: Optional[TriggeredUpdateStatus] = None
-    """Detailed status of an online table. Shown if the online table is in the ONLINE_TRIGGERED_UPDATE
-    or the ONLINE_NO_PENDING_UPDATE state."""
 
     def as_dict(self) -> dict:
         """Serializes the OnlineTableStatus into a dictionary suitable for use as a JSON request body."""
@@ -6839,6 +7769,169 @@ class OnlineTableStatus:
         )
 
 
+@dataclass
+class OptionSpec:
+    """Spec of an allowed option on a securable kind and its attributes. This is mostly used by UI to
+    provide user friendly hints and descriptions in order to facilitate the securable creation
+    process."""
+
+    allowed_values: Optional[List[str]] = None
+    """For drop down / radio button selections, UI will want to know the possible input values, it can
+    also be used by other option types to limit input selections."""
+
+    default_value: Optional[str] = None
+    """The default value of the option, for example, value '443' for 'port' option."""
+
+    description: Optional[str] = None
+    """A concise user facing description of what the input value of this option should look like."""
+
+    hint: Optional[str] = None
+    """The hint is used on the UI to suggest what the input value can possibly be like, for example:
+    example.com for 'host' option. Unlike default value, it will not be applied automatically
+    without user input."""
+
+    is_copiable: Optional[bool] = None
+    """Indicates whether an option should be displayed with copy button on the UI."""
+
+    is_creatable: Optional[bool] = None
+    """Indicates whether an option can be provided by users in the create/update path of an entity."""
+
+    is_hidden: Optional[bool] = None
+    """Is the option value not user settable and is thus not shown on the UI."""
+
+    is_loggable: Optional[bool] = None
+    """Specifies whether this option is safe to log, i.e. no sensitive information."""
+
+    is_required: Optional[bool] = None
+    """Is the option required."""
+
+    is_secret: Optional[bool] = None
+    """Is the option value considered secret and thus redacted on the UI."""
+
+    is_updatable: Optional[bool] = None
+    """Is the option updatable by users."""
+
+    name: Optional[str] = None
+    """The unique name of the option."""
+
+    oauth_stage: Optional[OptionSpecOauthStage] = None
+    """Specifies when the option value is displayed on the UI within the OAuth flow."""
+
+    type: Optional[OptionSpecOptionType] = None
+    """The type of the option."""
+
+    def as_dict(self) -> dict:
+        """Serializes the OptionSpec into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.allowed_values:
+            body["allowed_values"] = [v for v in self.allowed_values]
+        if self.default_value is not None:
+            body["default_value"] = self.default_value
+        if self.description is not None:
+            body["description"] = self.description
+        if self.hint is not None:
+            body["hint"] = self.hint
+        if self.is_copiable is not None:
+            body["is_copiable"] = self.is_copiable
+        if self.is_creatable is not None:
+            body["is_creatable"] = self.is_creatable
+        if self.is_hidden is not None:
+            body["is_hidden"] = self.is_hidden
+        if self.is_loggable is not None:
+            body["is_loggable"] = self.is_loggable
+        if self.is_required is not None:
+            body["is_required"] = self.is_required
+        if self.is_secret is not None:
+            body["is_secret"] = self.is_secret
+        if self.is_updatable is not None:
+            body["is_updatable"] = self.is_updatable
+        if self.name is not None:
+            body["name"] = self.name
+        if self.oauth_stage is not None:
+            body["oauth_stage"] = self.oauth_stage.value
+        if self.type is not None:
+            body["type"] = self.type.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the OptionSpec into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.allowed_values:
+            body["allowed_values"] = self.allowed_values
+        if self.default_value is not None:
+            body["default_value"] = self.default_value
+        if self.description is not None:
+            body["description"] = self.description
+        if self.hint is not None:
+            body["hint"] = self.hint
+        if self.is_copiable is not None:
+            body["is_copiable"] = self.is_copiable
+        if self.is_creatable is not None:
+            body["is_creatable"] = self.is_creatable
+        if self.is_hidden is not None:
+            body["is_hidden"] = self.is_hidden
+        if self.is_loggable is not None:
+            body["is_loggable"] = self.is_loggable
+        if self.is_required is not None:
+            body["is_required"] = self.is_required
+        if self.is_secret is not None:
+            body["is_secret"] = self.is_secret
+        if self.is_updatable is not None:
+            body["is_updatable"] = self.is_updatable
+        if self.name is not None:
+            body["name"] = self.name
+        if self.oauth_stage is not None:
+            body["oauth_stage"] = self.oauth_stage
+        if self.type is not None:
+            body["type"] = self.type
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> OptionSpec:
+        """Deserializes the OptionSpec from a dictionary."""
+        return cls(
+            allowed_values=d.get("allowed_values", None),
+            default_value=d.get("default_value", None),
+            description=d.get("description", None),
+            hint=d.get("hint", None),
+            is_copiable=d.get("is_copiable", None),
+            is_creatable=d.get("is_creatable", None),
+            is_hidden=d.get("is_hidden", None),
+            is_loggable=d.get("is_loggable", None),
+            is_required=d.get("is_required", None),
+            is_secret=d.get("is_secret", None),
+            is_updatable=d.get("is_updatable", None),
+            name=d.get("name", None),
+            oauth_stage=_enum(d, "oauth_stage", OptionSpecOauthStage),
+            type=_enum(d, "type", OptionSpecOptionType),
+        )
+
+
+class OptionSpecOauthStage(Enum):
+    """During the OAuth flow, specifies which stage the option should be displayed in the UI.
+    OAUTH_STAGE_UNSPECIFIED is the default value for options unrelated to the OAuth flow.
+    BEFORE_AUTHORIZATION_CODE corresponds to options necessary to initiate the OAuth process.
+    BEFORE_ACCESS_TOKEN corresponds to options that are necessary to create a foreign connection,
+    but that should be displayed after the authorization code has already been received."""
+
+    BEFORE_ACCESS_TOKEN = "BEFORE_ACCESS_TOKEN"
+    BEFORE_AUTHORIZATION_CODE = "BEFORE_AUTHORIZATION_CODE"
+
+
+class OptionSpecOptionType(Enum):
+    """Type of the option, we purposely follow JavaScript types so that the UI can map the options to
+    JS types. https://www.w3schools.com/js/js_datatypes.asp Enum is a special case that it's just
+    string with selections."""
+
+    OPTION_BIGINT = "OPTION_BIGINT"
+    OPTION_BOOLEAN = "OPTION_BOOLEAN"
+    OPTION_ENUM = "OPTION_ENUM"
+    OPTION_MULTILINE_STRING = "OPTION_MULTILINE_STRING"
+    OPTION_NUMBER = "OPTION_NUMBER"
+    OPTION_SERVICE_CREDENTIAL = "OPTION_SERVICE_CREDENTIAL"
+    OPTION_STRING = "OPTION_STRING"
+
+
 @dataclass
 class PermissionsChange:
     add: Optional[List[Privilege]] = None
@@ -6952,6 +8045,9 @@ class PrimaryKeyConstraint:
     child_columns: List[str]
     """Column names for this constraint."""
 
+    rely: Optional[bool] = None
+    """True if the constraint is RELY, false or unset if NORELY."""
+
     timeseries_columns: Optional[List[str]] = None
     """Column names that represent a timeseries."""
 
@@ -6962,6 +8058,8 @@ class PrimaryKeyConstraint:
             body["child_columns"] = [v for v in self.child_columns]
         if self.name is not None:
             body["name"] = self.name
+        if self.rely is not None:
+            body["rely"] = self.rely
         if self.timeseries_columns:
             body["timeseries_columns"] = [v for v in self.timeseries_columns]
         return body
@@ -6973,6 +8071,8 @@ class PrimaryKeyConstraint:
             body["child_columns"] = self.child_columns
         if self.name is not None:
             body["name"] = self.name
+        if self.rely is not None:
+            body["rely"] = self.rely
         if self.timeseries_columns:
             body["timeseries_columns"] = self.timeseries_columns
         return body
@@ -6983,6 +8083,7 @@ class PrimaryKeyConstraint:
         return cls(
             child_columns=d.get("child_columns", None),
             name=d.get("name", None),
+            rely=d.get("rely", None),
             timeseries_columns=d.get("timeseries_columns", None),
         )
 
@@ -7043,7 +8144,8 @@ class Privilege(Enum):
 @dataclass
 class PrivilegeAssignment:
     principal: Optional[str] = None
-    """The principal (user email address or group name)."""
+    """The principal (user email address or group name). For deleted principals, `principal` is empty
+    while `principal_id` is populated."""
 
     privileges: Optional[List[Privilege]] = None
     """The privileges assigned to the principal."""
@@ -7649,6 +8751,138 @@ class SchemaInfo:
         )
 
 
+class SecurableKind(Enum):
+    """Latest kind: TABLE_DELTA_ICEBERG_DELTASHARING = 252; Next id:253"""
+
+    TABLE_DB_STORAGE = "TABLE_DB_STORAGE"
+    TABLE_DELTA = "TABLE_DELTA"
+    TABLE_DELTASHARING = "TABLE_DELTASHARING"
+    TABLE_DELTASHARING_MUTABLE = "TABLE_DELTASHARING_MUTABLE"
+    TABLE_DELTA_EXTERNAL = "TABLE_DELTA_EXTERNAL"
+    TABLE_DELTA_ICEBERG_DELTASHARING = "TABLE_DELTA_ICEBERG_DELTASHARING"
+    TABLE_DELTA_ICEBERG_MANAGED = "TABLE_DELTA_ICEBERG_MANAGED"
+    TABLE_DELTA_UNIFORM_HUDI_EXTERNAL = "TABLE_DELTA_UNIFORM_HUDI_EXTERNAL"
+    TABLE_DELTA_UNIFORM_ICEBERG_EXTERNAL = "TABLE_DELTA_UNIFORM_ICEBERG_EXTERNAL"
+    TABLE_DELTA_UNIFORM_ICEBERG_FOREIGN_HIVE_METASTORE_EXTERNAL = (
+        "TABLE_DELTA_UNIFORM_ICEBERG_FOREIGN_HIVE_METASTORE_EXTERNAL"
+    )
+    TABLE_DELTA_UNIFORM_ICEBERG_FOREIGN_HIVE_METASTORE_MANAGED = (
+        "TABLE_DELTA_UNIFORM_ICEBERG_FOREIGN_HIVE_METASTORE_MANAGED"
+    )
+    TABLE_DELTA_UNIFORM_ICEBERG_FOREIGN_SNOWFLAKE = "TABLE_DELTA_UNIFORM_ICEBERG_FOREIGN_SNOWFLAKE"
+    TABLE_EXTERNAL = "TABLE_EXTERNAL"
+    TABLE_FEATURE_STORE = "TABLE_FEATURE_STORE"
+    TABLE_FEATURE_STORE_EXTERNAL = "TABLE_FEATURE_STORE_EXTERNAL"
+    TABLE_FOREIGN_BIGQUERY = "TABLE_FOREIGN_BIGQUERY"
+    TABLE_FOREIGN_DATABRICKS = "TABLE_FOREIGN_DATABRICKS"
+    TABLE_FOREIGN_DELTASHARING = "TABLE_FOREIGN_DELTASHARING"
+    TABLE_FOREIGN_HIVE_METASTORE = "TABLE_FOREIGN_HIVE_METASTORE"
+    TABLE_FOREIGN_HIVE_METASTORE_DBFS_EXTERNAL = "TABLE_FOREIGN_HIVE_METASTORE_DBFS_EXTERNAL"
+    TABLE_FOREIGN_HIVE_METASTORE_DBFS_MANAGED = "TABLE_FOREIGN_HIVE_METASTORE_DBFS_MANAGED"
+    TABLE_FOREIGN_HIVE_METASTORE_DBFS_SHALLOW_CLONE_EXTERNAL = (
+        "TABLE_FOREIGN_HIVE_METASTORE_DBFS_SHALLOW_CLONE_EXTERNAL"
+    )
+    TABLE_FOREIGN_HIVE_METASTORE_DBFS_SHALLOW_CLONE_MANAGED = "TABLE_FOREIGN_HIVE_METASTORE_DBFS_SHALLOW_CLONE_MANAGED"
+    TABLE_FOREIGN_HIVE_METASTORE_DBFS_VIEW = "TABLE_FOREIGN_HIVE_METASTORE_DBFS_VIEW"
+    TABLE_FOREIGN_HIVE_METASTORE_EXTERNAL = "TABLE_FOREIGN_HIVE_METASTORE_EXTERNAL"
+    TABLE_FOREIGN_HIVE_METASTORE_MANAGED = "TABLE_FOREIGN_HIVE_METASTORE_MANAGED"
+    TABLE_FOREIGN_HIVE_METASTORE_SHALLOW_CLONE_EXTERNAL = "TABLE_FOREIGN_HIVE_METASTORE_SHALLOW_CLONE_EXTERNAL"
+    TABLE_FOREIGN_HIVE_METASTORE_SHALLOW_CLONE_MANAGED = "TABLE_FOREIGN_HIVE_METASTORE_SHALLOW_CLONE_MANAGED"
+    TABLE_FOREIGN_HIVE_METASTORE_VIEW = "TABLE_FOREIGN_HIVE_METASTORE_VIEW"
+    TABLE_FOREIGN_MONGODB = "TABLE_FOREIGN_MONGODB"
+    TABLE_FOREIGN_MYSQL = "TABLE_FOREIGN_MYSQL"
+    TABLE_FOREIGN_NETSUITE = "TABLE_FOREIGN_NETSUITE"
+    TABLE_FOREIGN_ORACLE = "TABLE_FOREIGN_ORACLE"
+    TABLE_FOREIGN_POSTGRESQL = "TABLE_FOREIGN_POSTGRESQL"
+    TABLE_FOREIGN_REDSHIFT = "TABLE_FOREIGN_REDSHIFT"
+    TABLE_FOREIGN_SALESFORCE = "TABLE_FOREIGN_SALESFORCE"
+    TABLE_FOREIGN_SALESFORCE_DATA_CLOUD = "TABLE_FOREIGN_SALESFORCE_DATA_CLOUD"
+    TABLE_FOREIGN_SALESFORCE_DATA_CLOUD_FILE_SHARING = "TABLE_FOREIGN_SALESFORCE_DATA_CLOUD_FILE_SHARING"
+    TABLE_FOREIGN_SALESFORCE_DATA_CLOUD_FILE_SHARING_VIEW = "TABLE_FOREIGN_SALESFORCE_DATA_CLOUD_FILE_SHARING_VIEW"
+    TABLE_FOREIGN_SNOWFLAKE = "TABLE_FOREIGN_SNOWFLAKE"
+    TABLE_FOREIGN_SQLDW = "TABLE_FOREIGN_SQLDW"
+    TABLE_FOREIGN_SQLSERVER = "TABLE_FOREIGN_SQLSERVER"
+    TABLE_FOREIGN_TERADATA = "TABLE_FOREIGN_TERADATA"
+    TABLE_FOREIGN_WORKDAY_RAAS = "TABLE_FOREIGN_WORKDAY_RAAS"
+    TABLE_ICEBERG_UNIFORM_MANAGED = "TABLE_ICEBERG_UNIFORM_MANAGED"
+    TABLE_INTERNAL = "TABLE_INTERNAL"
+    TABLE_MANAGED_POSTGRESQL = "TABLE_MANAGED_POSTGRESQL"
+    TABLE_MATERIALIZED_VIEW = "TABLE_MATERIALIZED_VIEW"
+    TABLE_MATERIALIZED_VIEW_DELTASHARING = "TABLE_MATERIALIZED_VIEW_DELTASHARING"
+    TABLE_METRIC_VIEW = "TABLE_METRIC_VIEW"
+    TABLE_ONLINE_VECTOR_INDEX_DIRECT = "TABLE_ONLINE_VECTOR_INDEX_DIRECT"
+    TABLE_ONLINE_VECTOR_INDEX_REPLICA = "TABLE_ONLINE_VECTOR_INDEX_REPLICA"
+    TABLE_ONLINE_VIEW = "TABLE_ONLINE_VIEW"
+    TABLE_STANDARD = "TABLE_STANDARD"
+    TABLE_STREAMING_LIVE_TABLE = "TABLE_STREAMING_LIVE_TABLE"
+    TABLE_STREAMING_LIVE_TABLE_DELTASHARING = "TABLE_STREAMING_LIVE_TABLE_DELTASHARING"
+    TABLE_SYSTEM = "TABLE_SYSTEM"
+    TABLE_SYSTEM_DELTASHARING = "TABLE_SYSTEM_DELTASHARING"
+    TABLE_VIEW = "TABLE_VIEW"
+    TABLE_VIEW_DELTASHARING = "TABLE_VIEW_DELTASHARING"
+
+
+@dataclass
+class SecurableKindManifest:
+    """Manifest of a specific securable kind."""
+
+    assignable_privileges: Optional[List[str]] = None
+    """Privileges that can be assigned to the securable."""
+
+    capabilities: Optional[List[str]] = None
+    """A list of capabilities in the securable kind."""
+
+    options: Optional[List[OptionSpec]] = None
+    """Detailed specs of allowed options."""
+
+    securable_kind: Optional[SecurableKind] = None
+    """Securable kind to get manifest of."""
+
+    securable_type: Optional[SecurableType] = None
+    """Securable Type of the kind."""
+
+    def as_dict(self) -> dict:
+        """Serializes the SecurableKindManifest into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.assignable_privileges:
+            body["assignable_privileges"] = [v for v in self.assignable_privileges]
+        if self.capabilities:
+            body["capabilities"] = [v for v in self.capabilities]
+        if self.options:
+            body["options"] = [v.as_dict() for v in self.options]
+        if self.securable_kind is not None:
+            body["securable_kind"] = self.securable_kind.value
+        if self.securable_type is not None:
+            body["securable_type"] = self.securable_type.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the SecurableKindManifest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.assignable_privileges:
+            body["assignable_privileges"] = self.assignable_privileges
+        if self.capabilities:
+            body["capabilities"] = self.capabilities
+        if self.options:
+            body["options"] = self.options
+        if self.securable_kind is not None:
+            body["securable_kind"] = self.securable_kind
+        if self.securable_type is not None:
+            body["securable_type"] = self.securable_type
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> SecurableKindManifest:
+        """Deserializes the SecurableKindManifest from a dictionary."""
+        return cls(
+            assignable_privileges=d.get("assignable_privileges", None),
+            capabilities=d.get("capabilities", None),
+            options=_repeated_dict(d, "options", OptionSpec),
+            securable_kind=_enum(d, "securable_kind", SecurableKind),
+            securable_type=_enum(d, "securable_type", SecurableType),
+        )
+
+
 class SecurableType(Enum):
     """The type of Unity Catalog securable."""
 
@@ -7668,7 +8902,6 @@ class SecurableType(Enum):
     STAGING_TABLE = "STAGING_TABLE"
     STORAGE_CREDENTIAL = "STORAGE_CREDENTIAL"
     TABLE = "TABLE"
-    UNKNOWN_SECURABLE_TYPE = "UNKNOWN_SECURABLE_TYPE"
     VOLUME = "VOLUME"
 
 
@@ -7834,7 +9067,7 @@ class StorageCredentialInfo:
     """Comment associated with the credential."""
 
     created_at: Optional[int] = None
-    """Time at which this Credential was created, in epoch milliseconds."""
+    """Time at which this credential was created, in epoch milliseconds."""
 
     created_by: Optional[str] = None
     """Username of credential creator."""
@@ -7849,18 +9082,21 @@ class StorageCredentialInfo:
     """The unique identifier of the credential."""
 
     isolation_mode: Optional[IsolationMode] = None
+    """Whether the current securable is accessible from all workspaces or a specific set of workspaces."""
 
     metastore_id: Optional[str] = None
-    """Unique identifier of parent metastore."""
+    """Unique identifier of the parent metastore."""
 
     name: Optional[str] = None
-    """The credential name. The name must be unique within the metastore."""
+    """The credential name. The name must be unique among storage and service credentials within the
+    metastore."""
 
     owner: Optional[str] = None
     """Username of current owner of credential."""
 
     read_only: Optional[bool] = None
-    """Whether the storage credential is only usable for read operations."""
+    """Whether the credential is usable only for read operations. Only applicable when purpose is
+    **STORAGE**."""
 
     updated_at: Optional[int] = None
     """Time at which this credential was last modified, in epoch milliseconds."""
@@ -7869,7 +9105,8 @@ class StorageCredentialInfo:
     """Username of user who last modified the credential."""
 
     used_for_managed_storage: Optional[bool] = None
-    """Whether this credential is the current metastore's root storage credential."""
+    """Whether this credential is the current metastore's root storage credential. Only applicable when
+    purpose is **STORAGE**."""
 
     def as_dict(self) -> dict:
         """Serializes the StorageCredentialInfo into a dictionary suitable for use as a JSON request body."""
@@ -8014,6 +9251,31 @@ class SystemSchemaInfo:
         return cls(schema=d.get("schema", None), state=d.get("state", None))
 
 
+class SystemType(Enum):
+
+    AMAZON_REDSHIFT = "AMAZON_REDSHIFT"
+    AZURE_SYNAPSE = "AZURE_SYNAPSE"
+    CONFLUENT = "CONFLUENT"
+    GOOGLE_BIGQUERY = "GOOGLE_BIGQUERY"
+    KAFKA = "KAFKA"
+    LOOKER = "LOOKER"
+    MICROSOFT_FABRIC = "MICROSOFT_FABRIC"
+    MICROSOFT_SQL_SERVER = "MICROSOFT_SQL_SERVER"
+    MONGODB = "MONGODB"
+    MYSQL = "MYSQL"
+    ORACLE = "ORACLE"
+    OTHER = "OTHER"
+    POSTGRESQL = "POSTGRESQL"
+    POWER_BI = "POWER_BI"
+    SALESFORCE = "SALESFORCE"
+    SAP = "SAP"
+    SERVICENOW = "SERVICENOW"
+    SNOWFLAKE = "SNOWFLAKE"
+    TABLEAU = "TABLEAU"
+    TERADATA = "TERADATA"
+    WORKDAY = "WORKDAY"
+
+
 @dataclass
 class TableConstraint:
     """A table constraint, as defined by *one* of the following fields being set:
@@ -8138,7 +9400,6 @@ class TableInfo:
     """Unique ID of the Data Access Configuration to use with the table data."""
 
     data_source_format: Optional[DataSourceFormat] = None
-    """Data source format"""
 
     deleted_at: Optional[int] = None
     """Time at which this table was deleted, in epoch milliseconds. Field is omitted if table is not
@@ -8152,7 +9413,6 @@ class TableInfo:
     enable_predictive_optimization: Optional[EnablePredictiveOptimization] = None
 
     encryption_details: Optional[EncryptionDetails] = None
-    """Encryption options that apply to clients connecting to cloud storage."""
 
     full_name: Optional[str] = None
     """Full name of table, in form of __catalog_name__.__schema_name__.__table_name__"""
@@ -8178,6 +9438,9 @@ class TableInfo:
     schema_name: Optional[str] = None
     """Name of parent schema relative to its parent catalog."""
 
+    securable_kind_manifest: Optional[SecurableKindManifest] = None
+    """SecurableKindManifest of table, including capabilities the table has."""
+
     sql_path: Optional[str] = None
     """List of schemes whose objects can be referenced without qualification."""
 
@@ -8185,7 +9448,7 @@ class TableInfo:
     """Name of the storage credential, when a storage credential is configured for use with this table."""
 
     storage_location: Optional[str] = None
-    """Storage root URL for table (for **MANAGED**, **EXTERNAL** tables)"""
+    """Storage root URL for table (for **MANAGED**, **EXTERNAL** tables)."""
 
     table_constraints: Optional[List[TableConstraint]] = None
     """List of table constraints. Note: this field is not set in the output of the __listTables__ API."""
@@ -8258,6 +9521,8 @@ class TableInfo:
             body["row_filter"] = self.row_filter.as_dict()
         if self.schema_name is not None:
             body["schema_name"] = self.schema_name
+        if self.securable_kind_manifest:
+            body["securable_kind_manifest"] = self.securable_kind_manifest.as_dict()
         if self.sql_path is not None:
             body["sql_path"] = self.sql_path
         if self.storage_credential_name is not None:
@@ -8327,6 +9592,8 @@ class TableInfo:
             body["row_filter"] = self.row_filter
         if self.schema_name is not None:
             body["schema_name"] = self.schema_name
+        if self.securable_kind_manifest:
+            body["securable_kind_manifest"] = self.securable_kind_manifest
         if self.sql_path is not None:
             body["sql_path"] = self.sql_path
         if self.storage_credential_name is not None:
@@ -8379,6 +9646,7 @@ class TableInfo:
             properties=d.get("properties", None),
             row_filter=_from_dict(d, "row_filter", TableRowFilter),
             schema_name=d.get("schema_name", None),
+            securable_kind_manifest=_from_dict(d, "securable_kind_manifest", SecurableKindManifest),
             sql_path=d.get("sql_path", None),
             storage_credential_name=d.get("storage_credential_name", None),
             storage_location=d.get("storage_location", None),
@@ -8436,6 +9704,9 @@ class TableSummary:
     full_name: Optional[str] = None
     """The full name of the table."""
 
+    securable_kind_manifest: Optional[SecurableKindManifest] = None
+    """SecurableKindManifest of table, including capabilities the table has."""
+
     table_type: Optional[TableType] = None
 
     def as_dict(self) -> dict:
@@ -8443,6 +9714,8 @@ class TableSummary:
         body = {}
         if self.full_name is not None:
             body["full_name"] = self.full_name
+        if self.securable_kind_manifest:
+            body["securable_kind_manifest"] = self.securable_kind_manifest.as_dict()
         if self.table_type is not None:
             body["table_type"] = self.table_type.value
         return body
@@ -8452,6 +9725,8 @@ class TableSummary:
         body = {}
         if self.full_name is not None:
             body["full_name"] = self.full_name
+        if self.securable_kind_manifest:
+            body["securable_kind_manifest"] = self.securable_kind_manifest
         if self.table_type is not None:
             body["table_type"] = self.table_type
         return body
@@ -8459,7 +9734,11 @@ class TableSummary:
     @classmethod
     def from_dict(cls, d: Dict[str, Any]) -> TableSummary:
         """Deserializes the TableSummary from a dictionary."""
-        return cls(full_name=d.get("full_name", None), table_type=_enum(d, "table_type", TableType))
+        return cls(
+            full_name=d.get("full_name", None),
+            securable_kind_manifest=_from_dict(d, "securable_kind_manifest", SecurableKindManifest),
+            table_type=_enum(d, "table_type", TableType),
+        )
 
 
 class TableType(Enum):
@@ -8470,6 +9749,7 @@ class TableType(Enum):
     MANAGED = "MANAGED"
     MANAGED_SHALLOW_CLONE = "MANAGED_SHALLOW_CLONE"
     MATERIALIZED_VIEW = "MATERIALIZED_VIEW"
+    METRIC_VIEW = "METRIC_VIEW"
     STREAMING_TABLE = "STREAMING_TABLE"
     VIEW = "VIEW"
 
@@ -8509,21 +9789,14 @@ class TagKeyValue:
 @dataclass
 class TemporaryCredentials:
     aws_temp_credentials: Optional[AwsCredentials] = None
-    """AWS temporary credentials for API authentication. Read more at
-    https://docs.aws.amazon.com/STS/latest/APIReference/API_Credentials.html."""
 
     azure_aad: Optional[AzureActiveDirectoryToken] = None
-    """Azure Active Directory token, essentially the Oauth token for Azure Service Principal or Managed
-    Identity. Read more at
-    https://learn.microsoft.com/en-us/azure/databricks/dev-tools/api/latest/aad/service-prin-aad-token"""
 
     expiration_time: Optional[int] = None
     """Server time when the credential will expire, in epoch milliseconds. The API client is advised to
     cache the credential given this expiration time."""
 
     gcp_oauth_token: Optional[GcpOauthToken] = None
-    """GCP temporary credentials for API authentication. Read more at
-    https://developers.google.com/identity/protocols/oauth2/service-account"""
 
     def as_dict(self) -> dict:
         """Serializes the TemporaryCredentials into a dictionary suitable for use as a JSON request body."""
@@ -8808,19 +10081,19 @@ class UpdateConnection:
 @dataclass
 class UpdateCredentialRequest:
     aws_iam_role: Optional[AwsIamRole] = None
-    """The AWS IAM role configuration"""
+    """The AWS IAM role configuration."""
 
     azure_managed_identity: Optional[AzureManagedIdentity] = None
     """The Azure managed identity configuration."""
 
     azure_service_principal: Optional[AzureServicePrincipal] = None
-    """The Azure service principal configuration. Only applicable when purpose is **STORAGE**."""
+    """The Azure service principal configuration."""
 
     comment: Optional[str] = None
     """Comment associated with the credential."""
 
     databricks_gcp_service_account: Optional[DatabricksGcpServiceAccount] = None
-    """GCP long-lived credential. Databricks-created Google Cloud Storage service account."""
+    """The Databricks managed GCP service account configuration."""
 
     force: Optional[bool] = None
     """Force an update even if there are dependent services (when purpose is **SERVICE**) or dependent
@@ -8931,10 +10204,9 @@ class UpdateExternalLocation:
     """Name of the storage credential used with this location."""
 
     enable_file_events: Optional[bool] = None
-    """[Create:OPT Update:OPT] Whether to enable file events on this external location."""
+    """Whether to enable file events on this external location."""
 
     encryption_details: Optional[EncryptionDetails] = None
-    """Encryption options that apply to clients connecting to cloud storage."""
 
     fallback: Optional[bool] = None
     """Indicates whether fallback mode is enabled for this external location. When fallback mode is
@@ -8942,7 +10214,7 @@ class UpdateExternalLocation:
     sufficient."""
 
     file_event_queue: Optional[FileEventQueue] = None
-    """[Create:OPT Update:OPT] File event queue settings."""
+    """File event queue settings."""
 
     force: Optional[bool] = None
     """Force update even if changing url invalidates dependent external tables or mounts."""
@@ -9500,6 +10772,65 @@ class UpdateRegisteredModelRequest:
         )
 
 
+@dataclass
+class UpdateRequestExternalLineage:
+    source: ExternalLineageObject
+    """Source object of the external lineage relationship."""
+
+    target: ExternalLineageObject
+    """Target object of the external lineage relationship."""
+
+    columns: Optional[List[ColumnRelationship]] = None
+    """List of column relationships between source and target objects."""
+
+    id: Optional[str] = None
+    """Unique identifier of the external lineage relationship."""
+
+    properties: Optional[Dict[str, str]] = None
+    """Key-value properties associated with the external lineage relationship."""
+
+    def as_dict(self) -> dict:
+        """Serializes the UpdateRequestExternalLineage into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        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:
@@ -9609,6 +10940,7 @@ class UpdateStorageCredential:
     """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."""
@@ -9620,7 +10952,8 @@ class UpdateStorageCredential:
     """Username of current owner of credential."""
 
     read_only: Optional[bool] = None
-    """Whether the storage credential is only usable for read operations."""
+    """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 updated credential."""
@@ -9711,12 +11044,11 @@ class UpdateStorageCredential:
 
 @dataclass
 class UpdateTableRequest:
-    """Update a table owner."""
-
     full_name: Optional[str] = None
     """Full name of the table."""
 
     owner: Optional[str] = None
+    """Username of current owner of table."""
 
     def as_dict(self) -> dict:
         """Serializes the UpdateTableRequest into a dictionary suitable for use as a JSON request body."""
@@ -9920,16 +11252,13 @@ class ValidateCredentialRequest:
     """Next ID: 17"""
 
     aws_iam_role: Optional[AwsIamRole] = None
-    """The AWS IAM role configuration"""
 
     azure_managed_identity: Optional[AzureManagedIdentity] = None
-    """The Azure managed identity configuration."""
 
     credential_name: Optional[str] = None
     """Required. The name of an existing credential or long-lived cloud credential to validate."""
 
     databricks_gcp_service_account: Optional[DatabricksGcpServiceAccount] = None
-    """GCP long-lived credential. Databricks-created Google Cloud Storage service account."""
 
     external_location_name: Optional[str] = None
     """The name of an existing external location to validate. Only applicable for storage credentials
@@ -10067,7 +11396,7 @@ class ValidateStorageCredential:
     """Whether the storage credential is only usable for read operations."""
 
     storage_credential_name: Optional[str] = None
-    """The name of the storage credential to validate."""
+    """Required. The name of an existing credential or long-lived cloud credential to validate."""
 
     url: Optional[str] = None
     """The external location url to validate."""
@@ -10212,7 +11541,8 @@ class ValidationResult:
 
 
 class ValidationResultOperation(Enum):
-    """The operation tested."""
+    """A enum represents the file operation performed on the external location with the storage
+    credential"""
 
     DELETE = "DELETE"
     LIST = "LIST"
@@ -10222,7 +11552,7 @@ class ValidationResultOperation(Enum):
 
 
 class ValidationResultResult(Enum):
-    """The results of the tested operation."""
+    """A enum represents the result of the file operation"""
 
     FAIL = "FAIL"
     PASS = "PASS"
@@ -10250,7 +11580,6 @@ class VolumeInfo:
     """The identifier of the user who created the volume"""
 
     encryption_details: Optional[EncryptionDetails] = None
-    """Encryption options that apply to clients connecting to cloud storage."""
 
     full_name: Optional[str] = None
     """The three-level (fully qualified) name of the volume"""
@@ -10279,11 +11608,6 @@ class VolumeInfo:
     """The unique identifier of the volume"""
 
     volume_type: Optional[VolumeType] = None
-    """The type of the volume. An external volume is located in the specified external location. A
-    managed volume is located in the default location which is specified by the parent schema, or
-    the parent catalog, or the Metastore. [Learn more]
-    
-    [Learn more]: https://docs.databricks.com/aws/en/volumes/managed-vs-external"""
 
     def as_dict(self) -> dict:
         """Serializes the VolumeInfo into a dictionary suitable for use as a JSON request body."""
@@ -10449,9 +11773,7 @@ class AccountMetastoreAssignmentsAPI:
     def create(
         self, workspace_id: int, metastore_id: str, *, metastore_assignment: Optional[CreateMetastoreAssignment] = None
     ):
-        """Assigns a workspace to a metastore.
-
-        Creates an assignment to a metastore for a workspace
+        """Creates an assignment to a metastore for a workspace
 
         :param workspace_id: int
           Workspace ID.
@@ -10477,9 +11799,7 @@ class AccountMetastoreAssignmentsAPI:
         )
 
     def delete(self, workspace_id: int, metastore_id: str):
-        """Delete a metastore assignment.
-
-        Deletes a metastore assignment to a workspace, leaving the workspace with no metastore.
+        """Deletes a metastore assignment to a workspace, leaving the workspace with no metastore.
 
         :param workspace_id: int
           Workspace ID.
@@ -10500,9 +11820,7 @@ class AccountMetastoreAssignmentsAPI:
         )
 
     def get(self, workspace_id: int) -> AccountsMetastoreAssignment:
-        """Gets the metastore assignment for a workspace.
-
-        Gets the metastore assignment, if any, for the workspace specified by ID. If the workspace is assigned
+        """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.
 
@@ -10522,9 +11840,7 @@ class AccountMetastoreAssignmentsAPI:
         return AccountsMetastoreAssignment.from_dict(res)
 
     def list(self, metastore_id: str) -> Iterator[int]:
-        """Get all workspaces assigned to a metastore.
-
-        Gets a list of all Databricks workspace IDs that have been assigned to given metastore.
+        """Gets a list of all Databricks workspace IDs that have been assigned to given metastore.
 
         :param metastore_id: str
           Unity Catalog metastore ID
@@ -10545,9 +11861,7 @@ class AccountMetastoreAssignmentsAPI:
     def update(
         self, workspace_id: int, metastore_id: str, *, metastore_assignment: Optional[UpdateMetastoreAssignment] = None
     ):
-        """Updates a metastore assignment to a workspaces.
-
-        Updates an assignment to a metastore for a workspace. Currently, only the default catalog may be
+        """Updates an assignment to a metastore for a workspace. Currently, only the default catalog may be
         updated.
 
         :param workspace_id: int
@@ -10582,9 +11896,7 @@ class AccountMetastoresAPI:
         self._api = api_client
 
     def create(self, *, metastore_info: Optional[CreateMetastore] = None) -> AccountsMetastoreInfo:
-        """Create metastore.
-
-        Creates a Unity Catalog metastore.
+        """Creates a Unity Catalog metastore.
 
         :param metastore_info: :class:`CreateMetastore` (optional)
 
@@ -10602,9 +11914,7 @@ class AccountMetastoresAPI:
         return AccountsMetastoreInfo.from_dict(res)
 
     def delete(self, metastore_id: str, *, force: Optional[bool] = None):
-        """Delete a metastore.
-
-        Deletes a Unity Catalog metastore for an account, both specified by ID.
+        """Deletes a Unity Catalog metastore for an account, both specified by ID.
 
         :param metastore_id: str
           Unity Catalog metastore ID
@@ -10629,9 +11939,7 @@ class AccountMetastoresAPI:
         )
 
     def get(self, metastore_id: str) -> AccountsMetastoreInfo:
-        """Get a metastore.
-
-        Gets a Unity Catalog metastore from an account, both specified by ID.
+        """Gets a Unity Catalog metastore from an account, both specified by ID.
 
         :param metastore_id: str
           Unity Catalog metastore ID
@@ -10649,9 +11957,8 @@ class AccountMetastoresAPI:
         return AccountsMetastoreInfo.from_dict(res)
 
     def list(self) -> Iterator[MetastoreInfo]:
-        """Get all metastores associated with an account.
+        """Gets all Unity Catalog metastores associated with an account specified by ID.
 
-        Gets all Unity Catalog metastores associated with an account specified by ID.
 
         :returns: Iterator over :class:`MetastoreInfo`
         """
@@ -10665,9 +11972,7 @@ class AccountMetastoresAPI:
         return parsed if parsed is not None else []
 
     def update(self, metastore_id: str, *, metastore_info: Optional[UpdateMetastore] = None) -> AccountsMetastoreInfo:
-        """Update a metastore.
-
-        Updates an existing Unity Catalog metastore.
+        """Updates an existing Unity Catalog metastore.
 
         :param metastore_id: str
           Unity Catalog metastore ID
@@ -10698,9 +12003,7 @@ class AccountStorageCredentialsAPI:
     def create(
         self, metastore_id: str, *, credential_info: Optional[CreateStorageCredential] = None
     ) -> AccountsStorageCredentialInfo:
-        """Create a storage credential.
-
-        Creates a new storage credential. The request object is specific to the cloud:
+        """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.
@@ -10731,9 +12034,7 @@ class AccountStorageCredentialsAPI:
         return AccountsStorageCredentialInfo.from_dict(res)
 
     def delete(self, metastore_id: str, storage_credential_name: str, *, force: Optional[bool] = None):
-        """Delete a storage credential.
-
-        Deletes a storage credential from the metastore. The caller must be an owner of the storage
+        """Deletes a storage credential from the metastore. The caller must be an owner of the storage
         credential.
 
         :param metastore_id: str
@@ -10761,9 +12062,7 @@ class AccountStorageCredentialsAPI:
         )
 
     def get(self, metastore_id: str, storage_credential_name: str) -> AccountsStorageCredentialInfo:
-        """Gets the named storage credential.
-
-        Gets a storage credential from the metastore. The caller must be a metastore admin, the owner of the
+        """Gets a storage credential from the metastore. The caller must be a metastore admin, the owner of the
         storage credential, or have a level of privilege on the storage credential.
 
         :param metastore_id: str
@@ -10786,9 +12085,7 @@ class AccountStorageCredentialsAPI:
         return AccountsStorageCredentialInfo.from_dict(res)
 
     def list(self, metastore_id: str) -> Iterator[StorageCredentialInfo]:
-        """Get all storage credentials assigned to a metastore.
-
-        Gets a list of all storage credentials that have been assigned to given metastore.
+        """Gets a list of all storage credentials that have been assigned to given metastore.
 
         :param metastore_id: str
           Unity Catalog metastore ID
@@ -10815,9 +12112,7 @@ class AccountStorageCredentialsAPI:
         *,
         credential_info: Optional[UpdateStorageCredential] = None,
     ) -> AccountsStorageCredentialInfo:
-        """Updates a storage credential.
-
-        Updates a storage credential on the metastore. The caller must be the owner of the storage credential.
+        """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.
 
         :param metastore_id: str
@@ -10853,9 +12148,7 @@ class ArtifactAllowlistsAPI:
         self._api = api_client
 
     def get(self, artifact_type: ArtifactType) -> ArtifactAllowlistInfo:
-        """Get an artifact allowlist.
-
-        Get the artifact allowlist of a certain artifact type. The caller must be a metastore admin or have
+        """Get the artifact allowlist of a certain artifact type. The caller must be a metastore admin or have
         the **MANAGE ALLOWLIST** privilege on the metastore.
 
         :param artifact_type: :class:`ArtifactType`
@@ -10880,9 +12173,7 @@ class ArtifactAllowlistsAPI:
         created_by: Optional[str] = None,
         metastore_id: Optional[str] = None,
     ) -> ArtifactAllowlistInfo:
-        """Set an artifact allowlist.
-
-        Set the artifact allowlist of a certain artifact type. The whole artifact allowlist is replaced with
+        """Set the artifact allowlist of a certain artifact type. The whole artifact allowlist is replaced with
         the new allowlist. The caller must be a metastore admin or have the **MANAGE ALLOWLIST** privilege on
         the metastore.
 
@@ -10942,9 +12233,7 @@ class CatalogsAPI:
         share_name: Optional[str] = None,
         storage_root: Optional[str] = None,
     ) -> CatalogInfo:
-        """Create a catalog.
-
-        Creates a new catalog instance in the parent metastore if the caller is a metastore admin or has the
+        """Creates a new catalog instance in the parent metastore if the caller is a metastore admin or has the
         **CREATE_CATALOG** privilege.
 
         :param name: str
@@ -10994,9 +12283,7 @@ class CatalogsAPI:
         return CatalogInfo.from_dict(res)
 
     def delete(self, name: str, *, force: Optional[bool] = None):
-        """Delete a catalog.
-
-        Deletes the catalog that matches the supplied name. The caller must be a metastore admin or the owner
+        """Deletes the catalog that matches the supplied name. The caller must be a metastore admin or the owner
         of the catalog.
 
         :param name: str
@@ -11017,9 +12304,7 @@ class CatalogsAPI:
         self._api.do("DELETE", f"/api/2.1/unity-catalog/catalogs/{name}", query=query, headers=headers)
 
     def get(self, name: str, *, include_browse: Optional[bool] = None) -> CatalogInfo:
-        """Get a catalog.
-
-        Gets the specified catalog in a metastore. The caller must be a metastore admin, the owner of the
+        """Gets the specified catalog in a metastore. The caller must be a metastore admin, the owner of the
         catalog, or a user that has the **USE_CATALOG** privilege set for their account.
 
         :param name: str
@@ -11048,9 +12333,7 @@ class CatalogsAPI:
         max_results: Optional[int] = None,
         page_token: Optional[str] = None,
     ) -> Iterator[CatalogInfo]:
-        """List catalogs.
-
-        Gets an array of catalogs in the metastore. If the caller is the metastore admin, all catalogs will be
+        """Gets an array of catalogs in the metastore. If the caller is the metastore admin, all catalogs will be
         retrieved. Otherwise, only catalogs owned by the caller (or for which the caller has the
         **USE_CATALOG** privilege) will be retrieved. There is no guarantee of a specific ordering of the
         elements in the array.
@@ -11104,9 +12387,7 @@ class CatalogsAPI:
         owner: Optional[str] = None,
         properties: Optional[Dict[str, str]] = None,
     ) -> CatalogInfo:
-        """Update a catalog.
-
-        Updates the catalog that matches the supplied name. The caller must be either the owner of the
+        """Updates the catalog that matches the supplied name. The caller must be either the owner of the
         catalog, or a metastore admin (when changing the owner field of the catalog).
 
         :param name: str
@@ -11175,9 +12456,7 @@ class ConnectionsAPI:
         properties: Optional[Dict[str, str]] = None,
         read_only: Optional[bool] = None,
     ) -> ConnectionInfo:
-        """Create a connection.
-
-        Creates a new connection
+        """Creates a new connection
 
         Creates a new connection to an external data source. It allows users to specify connection details and
         configurations for interaction with the external server.
@@ -11219,9 +12498,7 @@ class ConnectionsAPI:
         return ConnectionInfo.from_dict(res)
 
     def delete(self, name: str):
-        """Delete a connection.
-
-        Deletes the connection that matches the supplied name.
+        """Deletes the connection that matches the supplied name.
 
         :param name: str
           The name of the connection to be deleted.
@@ -11236,9 +12513,7 @@ class ConnectionsAPI:
         self._api.do("DELETE", f"/api/2.1/unity-catalog/connections/{name}", headers=headers)
 
     def get(self, name: str) -> ConnectionInfo:
-        """Get a connection.
-
-        Gets a connection from it's name.
+        """Gets a connection from it's name.
 
         :param name: str
           Name of the connection.
@@ -11254,9 +12529,7 @@ class ConnectionsAPI:
         return ConnectionInfo.from_dict(res)
 
     def list(self, *, max_results: Optional[int] = None, page_token: Optional[str] = None) -> Iterator[ConnectionInfo]:
-        """List connections.
-
-        List all connections.
+        """List all connections.
 
         :param max_results: int (optional)
           Maximum number of connections to return. - If not set, all connections are returned (not
@@ -11290,9 +12563,7 @@ class ConnectionsAPI:
     def update(
         self, name: str, options: Dict[str, str], *, new_name: Optional[str] = None, owner: Optional[str] = None
     ) -> ConnectionInfo:
-        """Update a connection.
-
-        Updates the connection that matches the supplied name.
+        """Updates the connection that matches the supplied name.
 
         :param name: str
           Name of the connection.
@@ -11346,9 +12617,7 @@ class CredentialsAPI:
         read_only: Optional[bool] = None,
         skip_validation: Optional[bool] = None,
     ) -> CredentialInfo:
-        """Create a credential.
-
-        Creates a new credential. The type of credential to be created is determined by the **purpose** field,
+        """Creates a new credential. The type of credential to be created is determined by the **purpose** field,
         which should be either **SERVICE** or **STORAGE**.
 
         The caller must be a metastore admin or have the metastore privilege **CREATE_STORAGE_CREDENTIAL** for
@@ -11358,15 +12627,15 @@ class CredentialsAPI:
           The credential name. The name must be unique among storage and service credentials within the
           metastore.
         :param aws_iam_role: :class:`AwsIamRole` (optional)
-          The AWS IAM role configuration
+          The AWS IAM role configuration.
         :param azure_managed_identity: :class:`AzureManagedIdentity` (optional)
           The Azure managed identity configuration.
         :param azure_service_principal: :class:`AzureServicePrincipal` (optional)
-          The Azure service principal configuration. Only applicable when purpose is **STORAGE**.
+          The Azure service principal configuration.
         :param comment: str (optional)
           Comment associated with the credential.
         :param databricks_gcp_service_account: :class:`DatabricksGcpServiceAccount` (optional)
-          GCP long-lived credential. Databricks-created Google Cloud Storage service account.
+          The Databricks managed GCP service account configuration.
         :param purpose: :class:`CredentialPurpose` (optional)
           Indicates the purpose of the credential.
         :param read_only: bool (optional)
@@ -11405,9 +12674,7 @@ class CredentialsAPI:
         return CredentialInfo.from_dict(res)
 
     def delete_credential(self, name_arg: str, *, force: Optional[bool] = None):
-        """Delete a credential.
-
-        Deletes a service or storage credential from the metastore. The caller must be an owner of the
+        """Deletes a service or storage credential from the metastore. The caller must be an owner of the
         credential.
 
         :param name_arg: str
@@ -11435,17 +12702,13 @@ class CredentialsAPI:
         azure_options: Optional[GenerateTemporaryServiceCredentialAzureOptions] = None,
         gcp_options: Optional[GenerateTemporaryServiceCredentialGcpOptions] = None,
     ) -> TemporaryCredentials:
-        """Generate a temporary service credential.
-
-        Returns a set of temporary credentials generated using the specified service credential. The caller
+        """Returns a set of temporary credentials generated using the specified service credential. The caller
         must be a metastore admin or have the metastore privilege **ACCESS** on the service credential.
 
         :param credential_name: str
           The name of the service credential used to generate a temporary credential
         :param azure_options: :class:`GenerateTemporaryServiceCredentialAzureOptions` (optional)
-          The Azure cloud options to customize the requested temporary credential
         :param gcp_options: :class:`GenerateTemporaryServiceCredentialGcpOptions` (optional)
-          The GCP cloud options to customize the requested temporary credential
 
         :returns: :class:`TemporaryCredentials`
         """
@@ -11465,9 +12728,7 @@ class CredentialsAPI:
         return TemporaryCredentials.from_dict(res)
 
     def get_credential(self, name_arg: str) -> CredentialInfo:
-        """Get a credential.
-
-        Gets a service or storage credential from the metastore. The caller must be a metastore admin, the
+        """Gets a service or storage credential from the metastore. The caller must be a metastore admin, the
         owner of the credential, or have any permission on the credential.
 
         :param name_arg: str
@@ -11490,9 +12751,7 @@ class CredentialsAPI:
         page_token: Optional[str] = None,
         purpose: Optional[CredentialPurpose] = None,
     ) -> Iterator[CredentialInfo]:
-        """List credentials.
-
-        Gets an array of credentials (as __CredentialInfo__ objects).
+        """Gets an array of credentials (as __CredentialInfo__ objects).
 
         The array is limited to only the credentials that 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
@@ -11547,9 +12806,7 @@ class CredentialsAPI:
         read_only: Optional[bool] = None,
         skip_validation: Optional[bool] = None,
     ) -> CredentialInfo:
-        """Update a credential.
-
-        Updates a service or storage credential on the metastore.
+        """Updates a service or storage credential on the metastore.
 
         The caller must be the owner of the credential or a metastore admin or have the `MANAGE` permission.
         If the caller is a metastore admin, only the __owner__ field can be changed.
@@ -11557,15 +12814,15 @@ class CredentialsAPI:
         :param name_arg: str
           Name of the credential.
         :param aws_iam_role: :class:`AwsIamRole` (optional)
-          The AWS IAM role configuration
+          The AWS IAM role configuration.
         :param azure_managed_identity: :class:`AzureManagedIdentity` (optional)
           The Azure managed identity configuration.
         :param azure_service_principal: :class:`AzureServicePrincipal` (optional)
-          The Azure service principal configuration. Only applicable when purpose is **STORAGE**.
+          The Azure service principal configuration.
         :param comment: str (optional)
           Comment associated with the credential.
         :param databricks_gcp_service_account: :class:`DatabricksGcpServiceAccount` (optional)
-          GCP long-lived credential. Databricks-created Google Cloud Storage service account.
+          The Databricks managed GCP service account configuration.
         :param force: bool (optional)
           Force an update even if there are dependent services (when purpose is **SERVICE**) or dependent
           external locations and external tables (when purpose is **STORAGE**).
@@ -11626,9 +12883,7 @@ class CredentialsAPI:
         read_only: Optional[bool] = None,
         url: Optional[str] = None,
     ) -> ValidateCredentialResponse:
-        """Validate a credential.
-
-        Validates a credential.
+        """Validates a credential.
 
         For service credentials (purpose is **SERVICE**), either the __credential_name__ or the cloud-specific
         credential must be provided.
@@ -11643,13 +12898,10 @@ class CredentialsAPI:
         metastore and the credential (e.g., **CREATE_EXTERNAL_LOCATION** when purpose is **STORAGE**).
 
         :param aws_iam_role: :class:`AwsIamRole` (optional)
-          The AWS IAM role configuration
         :param azure_managed_identity: :class:`AzureManagedIdentity` (optional)
-          The Azure managed identity configuration.
         :param credential_name: str (optional)
           Required. The name of an existing credential or long-lived cloud credential to validate.
         :param databricks_gcp_service_account: :class:`DatabricksGcpServiceAccount` (optional)
-          GCP long-lived credential. Databricks-created Google Cloud Storage service account.
         :param external_location_name: str (optional)
           The name of an existing external location to validate. Only applicable for storage credentials
           (purpose is **STORAGE**.)
@@ -11689,6 +12941,132 @@ class CredentialsAPI:
         return ValidateCredentialResponse.from_dict(res)
 
 
+class ExternalLineageAPI:
+    """External Lineage APIs enable defining and managing lineage relationships between Databricks objects and
+    external systems. These APIs allow users to capture data flows connecting Databricks tables, models, and
+    file paths with external metadata objects.
+
+    With these APIs, users can create, update, delete, and list lineage relationships with support for
+    column-level mappings and custom properties."""
+
+    def __init__(self, api_client):
+        self._api = api_client
+
+    def create_external_lineage_relationship(
+        self, external_lineage_relationship: CreateRequestExternalLineage
+    ) -> ExternalLineageRelationship:
+        """Creates an external lineage relationship between a Databricks or external metadata object and another
+        external metadata object.
+
+        :param external_lineage_relationship: :class:`CreateRequestExternalLineage`
+
+        :returns: :class:`ExternalLineageRelationship`
+        """
+        body = external_lineage_relationship.as_dict()
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do("POST", "/api/2.0/lineage-tracking/external-lineage", body=body, headers=headers)
+        return ExternalLineageRelationship.from_dict(res)
+
+    def delete_external_lineage_relationship(self, external_lineage_relationship: DeleteRequestExternalLineage):
+        """Deletes an external lineage relationship between a Databricks or external metadata object and another
+        external metadata object.
+
+        :param external_lineage_relationship: :class:`DeleteRequestExternalLineage`
+
+
+        """
+
+        query = {}
+        if external_lineage_relationship is not None:
+            query["external_lineage_relationship"] = external_lineage_relationship.as_dict()
+        headers = {
+            "Accept": "application/json",
+        }
+
+        self._api.do("DELETE", "/api/2.0/lineage-tracking/external-lineage", query=query, headers=headers)
+
+    def list_external_lineage_relationships(
+        self,
+        object_info: ExternalLineageObject,
+        lineage_direction: LineageDirection,
+        *,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+    ) -> Iterator[ExternalLineageInfo]:
+        """Lists external lineage relationships of a Databricks object or external metadata given a supplied
+        direction.
+
+        :param object_info: :class:`ExternalLineageObject`
+          The object to query external lineage relationship on.
+        :param lineage_direction: :class:`LineageDirection`
+          The lineage direction to filter on.
+        :param page_size: int (optional)
+        :param page_token: str (optional)
+
+        :returns: Iterator over :class:`ExternalLineageInfo`
+        """
+
+        query = {}
+        if lineage_direction is not None:
+            query["lineage_direction"] = lineage_direction.value
+        if object_info is not None:
+            query["object_info"] = object_info.as_dict()
+        if page_size is not None:
+            query["page_size"] = page_size
+        if page_token is not None:
+            query["page_token"] = page_token
+        headers = {
+            "Accept": "application/json",
+        }
+
+        while True:
+            json = self._api.do("GET", "/api/2.0/lineage-tracking/external-lineage", query=query, headers=headers)
+            if "external_lineage_relationships" in json:
+                for v in json["external_lineage_relationships"]:
+                    yield ExternalLineageInfo.from_dict(v)
+            if "next_page_token" not in json or not json["next_page_token"]:
+                return
+            query["page_token"] = json["next_page_token"]
+
+    def update_external_lineage_relationship(
+        self, external_lineage_relationship: UpdateRequestExternalLineage, update_mask: str
+    ) -> ExternalLineageRelationship:
+        """Updates an external lineage relationship between a Databricks or external metadata object and another
+        external metadata object.
+
+        :param external_lineage_relationship: :class:`UpdateRequestExternalLineage`
+        :param update_mask: str
+          The field mask must be a single string, with multiple fields separated by commas (no spaces). The
+          field path is relative to the resource object, using a dot (`.`) to navigate sub-fields (e.g.,
+          `author.given_name`). Specification of elements in sequence or map fields is not allowed, as only
+          the entire collection field can be specified. Field names must exactly match the resource field
+          names.
+
+          A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
+          fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the API
+          changes in the future.
+
+        :returns: :class:`ExternalLineageRelationship`
+        """
+        body = external_lineage_relationship.as_dict()
+        query = {}
+        if update_mask is not None:
+            query["update_mask"] = update_mask
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do(
+            "PATCH", "/api/2.0/lineage-tracking/external-lineage", query=query, body=body, headers=headers
+        )
+        return ExternalLineageRelationship.from_dict(res)
+
+
 class ExternalLocationsAPI:
     """An external location is an object that combines a cloud storage path with a storage credential that
     authorizes access to the cloud storage path. Each external location is subject to Unity Catalog
@@ -11718,9 +13096,7 @@ class ExternalLocationsAPI:
         read_only: Optional[bool] = None,
         skip_validation: Optional[bool] = None,
     ) -> ExternalLocationInfo:
-        """Create an external location.
-
-        Creates a new external location entry in the metastore. The caller must be a metastore admin or have
+        """Creates a new external location entry in the metastore. The caller must be a metastore admin or have
         the **CREATE_EXTERNAL_LOCATION** privilege on both the metastore and the associated storage
         credential.
 
@@ -11733,15 +13109,14 @@ class ExternalLocationsAPI:
         :param comment: str (optional)
           User-provided free-form text description.
         :param enable_file_events: bool (optional)
-          [Create:OPT Update:OPT] Whether to enable file events on this external location.
+          Whether to enable file events on this external location.
         :param encryption_details: :class:`EncryptionDetails` (optional)
-          Encryption options that apply to clients connecting to cloud storage.
         :param fallback: bool (optional)
           Indicates whether fallback mode is enabled for this external location. When fallback mode is
           enabled, the access to the location falls back to cluster credentials if UC credentials are not
           sufficient.
         :param file_event_queue: :class:`FileEventQueue` (optional)
-          [Create:OPT Update:OPT] File event queue settings.
+          File event queue settings.
         :param read_only: bool (optional)
           Indicates whether the external location is read-only.
         :param skip_validation: bool (optional)
@@ -11779,9 +13154,7 @@ class ExternalLocationsAPI:
         return ExternalLocationInfo.from_dict(res)
 
     def delete(self, name: str, *, force: Optional[bool] = None):
-        """Delete an external location.
-
-        Deletes the specified external location from the metastore. The caller must be the owner of the
+        """Deletes the specified external location from the metastore. The caller must be the owner of the
         external location.
 
         :param name: str
@@ -11802,9 +13175,7 @@ class ExternalLocationsAPI:
         self._api.do("DELETE", f"/api/2.1/unity-catalog/external-locations/{name}", query=query, headers=headers)
 
     def get(self, name: str, *, include_browse: Optional[bool] = None) -> ExternalLocationInfo:
-        """Get an external location.
-
-        Gets an external location from the metastore. The caller must be either a metastore admin, the owner
+        """Gets an external location from the metastore. The caller must be either a metastore admin, the owner
         of the external location, or a user that has some privilege on the external location.
 
         :param name: str
@@ -11833,9 +13204,7 @@ class ExternalLocationsAPI:
         max_results: Optional[int] = None,
         page_token: Optional[str] = None,
     ) -> Iterator[ExternalLocationInfo]:
-        """List external locations.
-
-        Gets an array of external locations (__ExternalLocationInfo__ objects) from the metastore. The caller
+        """Gets an array of external locations (__ExternalLocationInfo__ objects) from the metastore. The caller
         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.
 
@@ -11891,9 +13260,7 @@ class ExternalLocationsAPI:
         skip_validation: Optional[bool] = None,
         url: Optional[str] = None,
     ) -> ExternalLocationInfo:
-        """Update an external location.
-
-        Updates an external location in the metastore. The caller must be the owner of the external location,
+        """Updates an external location in the metastore. The caller must be the owner of the external location,
         or be a metastore admin. In the second case, the admin can only update the name of the external
         location.
 
@@ -11904,15 +13271,14 @@ class ExternalLocationsAPI:
         :param credential_name: str (optional)
           Name of the storage credential used with this location.
         :param enable_file_events: bool (optional)
-          [Create:OPT Update:OPT] Whether to enable file events on this external location.
+          Whether to enable file events on this external location.
         :param encryption_details: :class:`EncryptionDetails` (optional)
-          Encryption options that apply to clients connecting to cloud storage.
         :param fallback: bool (optional)
           Indicates whether fallback mode is enabled for this external location. When fallback mode is
           enabled, the access to the location falls back to cluster credentials if UC credentials are not
           sufficient.
         :param file_event_queue: :class:`FileEventQueue` (optional)
-          [Create:OPT Update:OPT] File event queue settings.
+          File event queue settings.
         :param force: bool (optional)
           Force update even if changing url invalidates dependent external tables or mounts.
         :param isolation_mode: :class:`IsolationMode` (optional)
@@ -11965,6 +13331,137 @@ class ExternalLocationsAPI:
         return ExternalLocationInfo.from_dict(res)
 
 
+class ExternalMetadataAPI:
+    """External Metadata objects enable customers to register and manage metadata about external systems within
+    Unity Catalog.
+
+    These APIs provide a standardized way to create, update, retrieve, list, and delete external metadata
+    objects. Fine-grained authorization ensures that only users with appropriate permissions can view and
+    manage external metadata objects."""
+
+    def __init__(self, api_client):
+        self._api = api_client
+
+    def create_external_metadata(self, external_metadata: ExternalMetadata) -> ExternalMetadata:
+        """Creates a new external metadata object in the parent metastore if the caller is a metastore admin or
+        has the **CREATE_EXTERNAL_METADATA** privilege. Grants **BROWSE** to all account users upon creation
+        by default.
+
+        :param external_metadata: :class:`ExternalMetadata`
+
+        :returns: :class:`ExternalMetadata`
+        """
+        body = external_metadata.as_dict()
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do("POST", "/api/2.0/lineage-tracking/external-metadata", body=body, headers=headers)
+        return ExternalMetadata.from_dict(res)
+
+    def delete_external_metadata(self, name: str):
+        """Deletes the external metadata object that matches the supplied name. The caller must be a metastore
+        admin, the owner of the external metadata object, or a user that has the **MANAGE** privilege.
+
+        :param name: str
+
+
+        """
+
+        headers = {
+            "Accept": "application/json",
+        }
+
+        self._api.do("DELETE", f"/api/2.0/lineage-tracking/external-metadata/{name}", headers=headers)
+
+    def get_external_metadata(self, name: str) -> ExternalMetadata:
+        """Gets the specified external metadata object in a metastore. The caller must be a metastore admin, the
+        owner of the external metadata object, or a user that has the **BROWSE** privilege.
+
+        :param name: str
+
+        :returns: :class:`ExternalMetadata`
+        """
+
+        headers = {
+            "Accept": "application/json",
+        }
+
+        res = self._api.do("GET", f"/api/2.0/lineage-tracking/external-metadata/{name}", headers=headers)
+        return ExternalMetadata.from_dict(res)
+
+    def list_external_metadata(
+        self, *, page_size: Optional[int] = None, page_token: Optional[str] = None
+    ) -> Iterator[ExternalMetadata]:
+        """Gets an array of external metadata objects in the metastore. If the caller is the metastore admin, all
+        external metadata objects will be retrieved. Otherwise, only external metadata objects that the caller
+        has **BROWSE** on will be retrieved. There is no guarantee of a specific ordering of the elements in
+        the array.
+
+        :param page_size: int (optional)
+        :param page_token: str (optional)
+
+        :returns: Iterator over :class:`ExternalMetadata`
+        """
+
+        query = {}
+        if page_size is not None:
+            query["page_size"] = page_size
+        if page_token is not None:
+            query["page_token"] = page_token
+        headers = {
+            "Accept": "application/json",
+        }
+
+        while True:
+            json = self._api.do("GET", "/api/2.0/lineage-tracking/external-metadata", query=query, headers=headers)
+            if "external_metadata" in json:
+                for v in json["external_metadata"]:
+                    yield ExternalMetadata.from_dict(v)
+            if "next_page_token" not in json or not json["next_page_token"]:
+                return
+            query["page_token"] = json["next_page_token"]
+
+    def update_external_metadata(
+        self, name: str, external_metadata: ExternalMetadata, update_mask: str
+    ) -> ExternalMetadata:
+        """Updates the external metadata object that matches the supplied name. The caller can only update either
+        the owner or other metadata fields in one request. The caller must be a metastore admin, the owner of
+        the external metadata object, or a user that has the **MODIFY** privilege. If the caller is updating
+        the owner, they must also have the **MANAGE** privilege.
+
+        :param name: str
+          Name of the external metadata object.
+        :param external_metadata: :class:`ExternalMetadata`
+        :param update_mask: str
+          The field mask must be a single string, with multiple fields separated by commas (no spaces). The
+          field path is relative to the resource object, using a dot (`.`) to navigate sub-fields (e.g.,
+          `author.given_name`). Specification of elements in sequence or map fields is not allowed, as only
+          the entire collection field can be specified. Field names must exactly match the resource field
+          names.
+
+          A field mask of `*` indicates full replacement. It’s recommended to always explicitly list the
+          fields being updated and avoid using `*` wildcards, as it can lead to unintended results if the API
+          changes in the future.
+
+        :returns: :class:`ExternalMetadata`
+        """
+        body = external_metadata.as_dict()
+        query = {}
+        if update_mask is not None:
+            query["update_mask"] = update_mask
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        res = self._api.do(
+            "PATCH", f"/api/2.0/lineage-tracking/external-metadata/{name}", query=query, body=body, headers=headers
+        )
+        return ExternalMetadata.from_dict(res)
+
+
 class FunctionsAPI:
     """Functions implement User-Defined Functions (UDFs) in Unity Catalog.
 
@@ -11976,9 +13473,7 @@ class FunctionsAPI:
         self._api = api_client
 
     def create(self, function_info: CreateFunction) -> FunctionInfo:
-        """Create a function.
-
-        **WARNING: This API is experimental and will change in future versions**
+        """**WARNING: This API is experimental and will change in future versions**
 
         Creates a new function
 
@@ -12003,9 +13498,7 @@ class FunctionsAPI:
         return FunctionInfo.from_dict(res)
 
     def delete(self, name: str, *, force: Optional[bool] = None):
-        """Delete a function.
-
-        Deletes the function that matches the supplied name. For the deletion to succeed, the user must
+        """Deletes the function that matches the supplied name. For the deletion to succeed, the user must
         satisfy one of the following conditions: - Is the owner of the function's parent catalog - Is the
         owner of the function's parent schema and have the **USE_CATALOG** privilege on its parent catalog -
         Is the owner of the function itself and have both the **USE_CATALOG** privilege on its parent catalog
@@ -12030,9 +13523,7 @@ class FunctionsAPI:
         self._api.do("DELETE", f"/api/2.1/unity-catalog/functions/{name}", query=query, headers=headers)
 
     def get(self, name: str, *, include_browse: Optional[bool] = None) -> FunctionInfo:
-        """Get a function.
-
-        Gets a function from within a parent catalog and schema. For the fetch to succeed, the user must
+        """Gets a function from within a parent catalog and schema. For the fetch to succeed, the user must
         satisfy one of the following requirements: - Is a metastore admin - Is an owner of the function's
         parent catalog - Have the **USE_CATALOG** privilege on the function's parent catalog and be the owner
         of the function - Have the **USE_CATALOG** privilege on the function's parent catalog, the
@@ -12068,9 +13559,7 @@ class FunctionsAPI:
         max_results: Optional[int] = None,
         page_token: Optional[str] = None,
     ) -> Iterator[FunctionInfo]:
-        """List functions.
-
-        List functions within the specified parent catalog and schema. If the user is a metastore admin, all
+        """List functions within the specified parent catalog and schema. If the user is a metastore admin, all
         functions are returned in the output list. Otherwise, the user must have the **USE_CATALOG** privilege
         on the catalog and the **USE_SCHEMA** privilege on the schema, and the output list contains only
         functions for which either the user has the **EXECUTE** privilege or the user is the owner. There is
@@ -12119,9 +13608,7 @@ class FunctionsAPI:
             query["page_token"] = json["next_page_token"]
 
     def update(self, name: str, *, owner: Optional[str] = None) -> FunctionInfo:
-        """Update a function.
-
-        Updates the function that matches the supplied name. Only the owner of the function can be updated. If
+        """Updates the function that matches the supplied name. Only the owner of the function can be updated. If
         the user is not a metastore admin, the user must be a member of the group that is the new function
         owner. - Is a metastore admin - Is the owner of the function's parent catalog - Is the owner of the
         function's parent schema and has the **USE_CATALOG** privilege on its parent catalog - Is the owner of
@@ -12171,9 +13658,7 @@ class GrantsAPI:
         page_token: Optional[str] = None,
         principal: Optional[str] = None,
     ) -> GetPermissionsResponse:
-        """Get permissions.
-
-        Gets the permissions for a securable. Does not include inherited permissions.
+        """Gets the permissions for a securable. Does not include inherited permissions.
 
         :param securable_type: str
           Type of securable.
@@ -12222,9 +13707,7 @@ class GrantsAPI:
         page_token: Optional[str] = None,
         principal: Optional[str] = None,
     ) -> EffectivePermissionsList:
-        """Get effective permissions.
-
-        Gets the effective permissions for a securable. Includes inherited permissions from any parent
+        """Gets the effective permissions for a securable. Includes inherited permissions from any parent
         securables.
 
         :param securable_type: str
@@ -12273,9 +13756,7 @@ class GrantsAPI:
     def update(
         self, securable_type: str, full_name: str, *, changes: Optional[List[PermissionsChange]] = None
     ) -> UpdatePermissionsResponse:
-        """Update permissions.
-
-        Updates the permissions for a securable.
+        """Updates the permissions for a securable.
 
         :param securable_type: str
           Type of securable.
@@ -12317,9 +13798,7 @@ class MetastoresAPI:
         self._api = api_client
 
     def assign(self, workspace_id: int, metastore_id: str, default_catalog_name: str):
-        """Create an assignment.
-
-        Creates a new metastore assignment. If an assignment for the same __workspace_id__ exists, it will be
+        """Creates a new metastore assignment. If an assignment for the same __workspace_id__ exists, it will be
         overwritten by the new __metastore_id__ and __default_catalog_name__. The caller must be an account
         admin.
 
@@ -12346,9 +13825,7 @@ class MetastoresAPI:
         self._api.do("PUT", f"/api/2.1/unity-catalog/workspaces/{workspace_id}/metastore", body=body, headers=headers)
 
     def create(self, name: str, *, region: Optional[str] = None, storage_root: Optional[str] = None) -> MetastoreInfo:
-        """Create a metastore.
-
-        Creates a new metastore based on a provided name and optional storage root path. By default (if the
+        """Creates a new metastore based on a provided name and optional storage root path. By default (if the
         __owner__ field is not set), the owner of the new metastore is the user calling the
         __createMetastore__ API. If the __owner__ field is set to the empty string (**""**), the ownership is
         assigned to the System User instead.
@@ -12378,9 +13855,8 @@ class MetastoresAPI:
         return MetastoreInfo.from_dict(res)
 
     def current(self) -> MetastoreAssignment:
-        """Get metastore assignment for workspace.
+        """Gets the metastore assignment for the workspace being accessed.
 
-        Gets the metastore assignment for the workspace being accessed.
 
         :returns: :class:`MetastoreAssignment`
         """
@@ -12393,9 +13869,7 @@ class MetastoresAPI:
         return MetastoreAssignment.from_dict(res)
 
     def delete(self, id: str, *, force: Optional[bool] = None):
-        """Delete a metastore.
-
-        Deletes a metastore. The caller must be a metastore admin.
+        """Deletes a metastore. The caller must be a metastore admin.
 
         :param id: str
           Unique ID of the metastore.
@@ -12415,9 +13889,7 @@ class MetastoresAPI:
         self._api.do("DELETE", f"/api/2.1/unity-catalog/metastores/{id}", query=query, headers=headers)
 
     def get(self, id: str) -> MetastoreInfo:
-        """Get a metastore.
-
-        Gets a metastore that matches the supplied ID. The caller must be a metastore admin to retrieve this
+        """Gets a metastore that matches the supplied ID. The caller must be a metastore admin to retrieve this
         info.
 
         :param id: str
@@ -12434,9 +13906,7 @@ class MetastoresAPI:
         return MetastoreInfo.from_dict(res)
 
     def list(self, *, max_results: Optional[int] = None, page_token: Optional[str] = None) -> Iterator[MetastoreInfo]:
-        """List metastores.
-
-        Gets an array of the available metastores (as __MetastoreInfo__ objects). The caller must be an admin
+        """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.
 
         :param max_results: int (optional)
@@ -12472,11 +13942,10 @@ class MetastoresAPI:
             query["page_token"] = json["next_page_token"]
 
     def summary(self) -> GetMetastoreSummaryResponse:
-        """Get a metastore summary.
-
-        Gets information about a metastore. This summary includes the storage credential, the cloud vendor,
+        """Gets information about a metastore. This summary includes the storage credential, the cloud vendor,
         the cloud region, and the global metastore ID.
 
+
         :returns: :class:`GetMetastoreSummaryResponse`
         """
 
@@ -12488,9 +13957,7 @@ class MetastoresAPI:
         return GetMetastoreSummaryResponse.from_dict(res)
 
     def unassign(self, workspace_id: int, metastore_id: str):
-        """Delete an assignment.
-
-        Deletes a metastore assignment. The caller must be an account administrator.
+        """Deletes a metastore assignment. The caller must be an account administrator.
 
         :param workspace_id: int
           A workspace ID.
@@ -12523,9 +13990,7 @@ class MetastoresAPI:
         privilege_model_version: Optional[str] = None,
         storage_root_credential_id: Optional[str] = None,
     ) -> MetastoreInfo:
-        """Update a metastore.
-
-        Updates information for a specific metastore. The caller must be a metastore admin. If the __owner__
+        """Updates information for a specific metastore. The caller must be a metastore admin. If the __owner__
         field is set to the empty string (**""**), the ownership is updated to the System User.
 
         :param id: str
@@ -12576,9 +14041,7 @@ class MetastoresAPI:
     def update_assignment(
         self, workspace_id: int, *, default_catalog_name: Optional[str] = None, metastore_id: Optional[str] = None
     ):
-        """Update an assignment.
-
-        Updates a metastore assignment. This operation can be used to update __metastore_id__ or
+        """Updates a metastore assignment. This operation can be used to update __metastore_id__ or
         __default_catalog_name__ for a specified Workspace, if the Workspace is already assigned a metastore.
         The caller must be an account admin to update __metastore_id__; otherwise, the caller can be a
         Workspace admin.
@@ -12618,9 +14081,7 @@ class ModelVersionsAPI:
         self._api = api_client
 
     def delete(self, full_name: str, version: int):
-        """Delete a Model Version.
-
-        Deletes a model version from the specified registered model. Any aliases assigned to the model version
+        """Deletes a model version from the specified registered model. Any aliases assigned to the model version
         will also be deleted.
 
         The caller must be a metastore admin or an owner of the parent registered model. For the latter case,
@@ -12647,9 +14108,7 @@ class ModelVersionsAPI:
         include_aliases: Optional[bool] = None,
         include_browse: Optional[bool] = None,
     ) -> ModelVersionInfo:
-        """Get a Model Version.
-
-        Get a model version.
+        """Get a model version.
 
         The caller must be a metastore admin or an owner of (or have the **EXECUTE** privilege on) the parent
         registered model. For the latter case, the caller must also be the owner or have the **USE_CATALOG**
@@ -12683,9 +14142,7 @@ class ModelVersionsAPI:
         return ModelVersionInfo.from_dict(res)
 
     def get_by_alias(self, full_name: str, alias: str, *, include_aliases: Optional[bool] = None) -> ModelVersionInfo:
-        """Get Model Version By Alias.
-
-        Get a model version by alias.
+        """Get a model version by alias.
 
         The caller must be a metastore admin or an owner of (or have the **EXECUTE** privilege on) the
         registered model. For the latter case, the caller must also be the owner or have the **USE_CATALOG**
@@ -12721,9 +14178,7 @@ class ModelVersionsAPI:
         max_results: Optional[int] = None,
         page_token: Optional[str] = None,
     ) -> Iterator[ModelVersionInfo]:
-        """List Model Versions.
-
-        List model versions. You can list model versions under a particular schema, or list all model versions
+        """List model versions. You can list model versions under a particular schema, or list all model versions
         in the current metastore.
 
         The returned models are filtered based on the privileges of the calling user. For example, the
@@ -12775,9 +14230,7 @@ class ModelVersionsAPI:
             query["page_token"] = json["next_page_token"]
 
     def update(self, full_name: str, version: int, *, comment: Optional[str] = None) -> ModelVersionInfo:
-        """Update a Model Version.
-
-        Updates the specified model version.
+        """Updates the specified model version.
 
         The caller must be a metastore admin or an owner of the parent registered model. For the latter case,
         the caller must also be the owner or have the **USE_CATALOG** privilege on the parent catalog and the
@@ -12844,12 +14297,10 @@ class OnlineTablesAPI:
         raise TimeoutError(f"timed out after {timeout}: {status_message}")
 
     def create(self, table: OnlineTable) -> Wait[OnlineTable]:
-        """Create an Online Table.
-
-        Create a new Online Table.
+        """Create a new Online Table.
 
         :param table: :class:`OnlineTable`
-          Online Table information.
+          Specification of the online table to be created.
 
         :returns:
           Long-running operation waiter for :class:`OnlineTable`.
@@ -12870,9 +14321,7 @@ class OnlineTablesAPI:
         return self.create(table=table).result(timeout=timeout)
 
     def delete(self, name: str):
-        """Delete an Online Table.
-
-        Delete an online table. Warning: This will delete all the data in the online table. If the source
+        """Delete an online table. Warning: This will delete all the data in the online table. If the source
         Delta table was deleted or modified since this Online Table was created, this will lose the data
         forever!
 
@@ -12889,9 +14338,7 @@ class OnlineTablesAPI:
         self._api.do("DELETE", f"/api/2.0/online-tables/{name}", headers=headers)
 
     def get(self, name: str) -> OnlineTable:
-        """Get an Online Table.
-
-        Get information about an existing online table and its status.
+        """Get information about an existing online table and its status.
 
         :param name: str
           Full three-part (catalog, schema, table) name of the table.
@@ -12919,9 +14366,7 @@ class QualityMonitorsAPI:
         self._api = api_client
 
     def cancel_refresh(self, table_name: str, refresh_id: str):
-        """Cancel refresh.
-
-        Cancel an active monitor refresh for the given refresh ID.
+        """Cancel an active monitor refresh for the given refresh ID.
 
         The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
         table's parent catalog and be an owner of the table's parent schema 3. have the following permissions:
@@ -12962,9 +14407,7 @@ class QualityMonitorsAPI:
         time_series: Optional[MonitorTimeSeries] = None,
         warehouse_id: Optional[str] = None,
     ) -> MonitorInfo:
-        """Create a table monitor.
-
-        Creates a new monitor for the specified table.
+        """Creates a new monitor for the specified table.
 
         The caller must either: 1. be an owner of the table's parent catalog, have **USE_SCHEMA** on the
         table's parent schema, and have **SELECT** access on the table 2. have **USE_CATALOG** on the table's
@@ -13046,9 +14489,7 @@ class QualityMonitorsAPI:
         return MonitorInfo.from_dict(res)
 
     def delete(self, table_name: str):
-        """Delete a table monitor.
-
-        Deletes a monitor for the specified table.
+        """Deletes a monitor for the specified table.
 
         The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
         table's parent catalog and be an owner of the table's parent schema 3. have the following permissions:
@@ -13071,9 +14512,7 @@ class QualityMonitorsAPI:
         self._api.do("DELETE", f"/api/2.1/unity-catalog/tables/{table_name}/monitor", headers=headers)
 
     def get(self, table_name: str) -> MonitorInfo:
-        """Get a table monitor.
-
-        Gets a monitor for the specified table.
+        """Gets a monitor for the specified table.
 
         The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
         table's parent catalog and be an owner of the table's parent schema. 3. have the following
@@ -13098,9 +14537,7 @@ class QualityMonitorsAPI:
         return MonitorInfo.from_dict(res)
 
     def get_refresh(self, table_name: str, refresh_id: str) -> MonitorRefreshInfo:
-        """Get refresh.
-
-        Gets info about a specific monitor refresh using the given refresh ID.
+        """Gets info about a specific monitor refresh using the given refresh ID.
 
         The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
         table's parent catalog and be an owner of the table's parent schema 3. have the following permissions:
@@ -13127,9 +14564,7 @@ class QualityMonitorsAPI:
         return MonitorRefreshInfo.from_dict(res)
 
     def list_refreshes(self, table_name: str) -> MonitorRefreshListResponse:
-        """List refreshes.
-
-        Gets an array containing the history of the most recent refreshes (up to 25) for this table.
+        """Gets an array containing the history of the most recent refreshes (up to 25) for this table.
 
         The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
         table's parent catalog and be an owner of the table's parent schema 3. have the following permissions:
@@ -13154,9 +14589,7 @@ class QualityMonitorsAPI:
     def regenerate_dashboard(
         self, table_name: str, *, warehouse_id: Optional[str] = None
     ) -> RegenerateDashboardResponse:
-        """Regenerate a monitoring dashboard.
-
-        Regenerates the monitoring dashboard for the specified table.
+        """Regenerates the monitoring dashboard for the specified table.
 
         The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
         table's parent catalog and be an owner of the table's parent schema 3. have the following permissions:
@@ -13188,9 +14621,7 @@ class QualityMonitorsAPI:
         return RegenerateDashboardResponse.from_dict(res)
 
     def run_refresh(self, table_name: str) -> MonitorRefreshInfo:
-        """Queue a metric refresh for a monitor.
-
-        Queues a metric refresh on the monitor for the specified table. The refresh will execute in the
+        """Queues a metric refresh on the monitor for the specified table. The refresh will execute in the
         background.
 
         The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
@@ -13229,9 +14660,7 @@ class QualityMonitorsAPI:
         snapshot: Optional[MonitorSnapshot] = None,
         time_series: Optional[MonitorTimeSeries] = None,
     ) -> MonitorInfo:
-        """Update a table monitor.
-
-        Updates a monitor for the specified table.
+        """Updates a monitor for the specified table.
 
         The caller must either: 1. be an owner of the table's parent catalog 2. have **USE_CATALOG** on the
         table's parent catalog and be an owner of the table's parent schema 3. have the following permissions:
@@ -13345,9 +14774,7 @@ class RegisteredModelsAPI:
         comment: Optional[str] = None,
         storage_location: Optional[str] = None,
     ) -> RegisteredModelInfo:
-        """Create a Registered Model.
-
-        Creates a new registered model in Unity Catalog.
+        """Creates a new registered model in Unity Catalog.
 
         File storage for model versions in the registered model will be located in the default location which
         is specified by the parent schema, or the parent catalog, or the Metastore.
@@ -13390,9 +14817,7 @@ class RegisteredModelsAPI:
         return RegisteredModelInfo.from_dict(res)
 
     def delete(self, full_name: str):
-        """Delete a Registered Model.
-
-        Deletes a registered model and all its model versions from the specified parent catalog and schema.
+        """Deletes a registered model and all its model versions from the specified parent catalog and schema.
 
         The caller must be a metastore admin or an owner of the registered model. For the latter case, the
         caller must also be the owner or have the **USE_CATALOG** privilege on the parent catalog and the
@@ -13409,9 +14834,7 @@ class RegisteredModelsAPI:
         self._api.do("DELETE", f"/api/2.1/unity-catalog/models/{full_name}", headers=headers)
 
     def delete_alias(self, full_name: str, alias: str):
-        """Delete a Registered Model Alias.
-
-        Deletes a registered model alias.
+        """Deletes a registered model alias.
 
         The caller must be a metastore admin or an owner of the registered model. For the latter case, the
         caller must also be the owner or have the **USE_CATALOG** privilege on the parent catalog and the
@@ -13432,9 +14855,7 @@ class RegisteredModelsAPI:
     def get(
         self, full_name: str, *, include_aliases: Optional[bool] = None, include_browse: Optional[bool] = None
     ) -> RegisteredModelInfo:
-        """Get a Registered Model.
-
-        Get a registered model.
+        """Get a registered model.
 
         The caller must be a metastore admin or an owner of (or have the **EXECUTE** privilege on) the
         registered model. For the latter case, the caller must also be the owner or have the **USE_CATALOG**
@@ -13472,9 +14893,7 @@ class RegisteredModelsAPI:
         page_token: Optional[str] = None,
         schema_name: Optional[str] = None,
     ) -> Iterator[RegisteredModelInfo]:
-        """List Registered Models.
-
-        List registered models. You can list registered models under a particular schema, or list all
+        """List registered models. You can list registered models under a particular schema, or list all
         registered models in the current metastore.
 
         The returned models are filtered based on the privileges of the calling user. For example, the
@@ -13539,9 +14958,7 @@ class RegisteredModelsAPI:
             query["page_token"] = json["next_page_token"]
 
     def set_alias(self, full_name: str, alias: str, version_num: int) -> RegisteredModelAlias:
-        """Set a Registered Model Alias.
-
-        Set an alias on the specified registered model.
+        """Set an alias on the specified registered model.
 
         The caller must be a metastore admin or an owner of the registered model. For the latter case, the
         caller must also be the owner or have the **USE_CATALOG** privilege on the parent catalog and the
@@ -13577,9 +14994,7 @@ class RegisteredModelsAPI:
         new_name: Optional[str] = None,
         owner: Optional[str] = None,
     ) -> RegisteredModelInfo:
-        """Update a Registered Model.
-
-        Updates the specified registered model.
+        """Updates the specified registered model.
 
         The caller must be a metastore admin or an owner of the registered model. For the latter case, the
         caller must also be the owner or have the **USE_CATALOG** privilege on the parent catalog and the
@@ -13627,9 +15042,7 @@ class ResourceQuotasAPI:
         self._api = api_client
 
     def get_quota(self, parent_securable_type: str, parent_full_name: str, quota_name: str) -> GetQuotaResponse:
-        """Get information for a single resource quota.
-
-        The GetQuota API returns usage information for a single resource quota, defined as a child-parent
+        """The GetQuota API returns usage information for a single resource quota, defined as a child-parent
         pair. This API also refreshes the quota count if it is out of date. Refreshes are triggered
         asynchronously. The updated count might not be returned in the first call.
 
@@ -13657,9 +15070,7 @@ class ResourceQuotasAPI:
     def list_quotas(
         self, *, max_results: Optional[int] = None, page_token: Optional[str] = None
     ) -> Iterator[QuotaInfo]:
-        """List all resource quotas under a metastore.
-
-        ListQuotas returns all quota values under the metastore. There are no SLAs on the freshness of the
+        """ListQuotas returns all quota values under the metastore. There are no SLAs on the freshness of the
         counts returned. This API does not trigger a refresh of quota counts.
 
         :param max_results: int (optional)
@@ -13709,9 +15120,7 @@ class SchemasAPI:
         properties: Optional[Dict[str, str]] = None,
         storage_root: Optional[str] = None,
     ) -> SchemaInfo:
-        """Create a schema.
-
-        Creates a new schema for catalog in the Metatastore. The caller must be a metastore admin, or have the
+        """Creates a new schema for catalog in the Metatastore. The caller must be a metastore admin, or have the
         **CREATE_SCHEMA** privilege in the parent catalog.
 
         :param name: str
@@ -13747,9 +15156,7 @@ class SchemasAPI:
         return SchemaInfo.from_dict(res)
 
     def delete(self, full_name: str, *, force: Optional[bool] = None):
-        """Delete a schema.
-
-        Deletes the specified schema from the parent catalog. The caller must be the owner of the schema or an
+        """Deletes the specified schema from the parent catalog. The caller must be the owner of the schema or an
         owner of the parent catalog.
 
         :param full_name: str
@@ -13770,9 +15177,7 @@ class SchemasAPI:
         self._api.do("DELETE", f"/api/2.1/unity-catalog/schemas/{full_name}", query=query, headers=headers)
 
     def get(self, full_name: str, *, include_browse: Optional[bool] = None) -> SchemaInfo:
-        """Get a schema.
-
-        Gets the specified schema within the metastore. The caller must be a metastore admin, the owner of the
+        """Gets the specified schema within the metastore. The caller must be a metastore admin, the owner of the
         schema, or a user that has the **USE_SCHEMA** privilege on the schema.
 
         :param full_name: str
@@ -13802,9 +15207,7 @@ class SchemasAPI:
         max_results: Optional[int] = None,
         page_token: Optional[str] = None,
     ) -> Iterator[SchemaInfo]:
-        """List schemas.
-
-        Gets an array of schemas for a catalog in the metastore. If the caller is the metastore admin or the
+        """Gets an array of schemas for a catalog in the metastore. If the caller is the metastore admin or the
         owner of the parent catalog, all schemas for the catalog will be retrieved. Otherwise, only schemas
         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.
@@ -13857,9 +15260,7 @@ class SchemasAPI:
         owner: Optional[str] = None,
         properties: Optional[Dict[str, str]] = None,
     ) -> SchemaInfo:
-        """Update a schema.
-
-        Updates a schema for a catalog. The caller must be the owner of the schema or a metastore admin. If
+        """Updates a schema for a catalog. The caller must be the owner of the schema or a metastore admin. If
         the caller is a metastore admin, only the __owner__ field can be changed in the update. If the
         __name__ field must be updated, the caller must be a metastore admin or have the **CREATE_SCHEMA**
         privilege on the parent catalog.
@@ -13927,12 +15328,14 @@ class StorageCredentialsAPI:
         read_only: Optional[bool] = None,
         skip_validation: Optional[bool] = None,
     ) -> StorageCredentialInfo:
-        """Create a storage credential.
+        """Creates a new storage credential.
 
-        Creates a new storage credential.
+        The caller must be a metastore admin or have the **CREATE_STORAGE_CREDENTIAL** privilege on the
+        metastore.
 
         :param name: str
-          The credential name. The name must be unique within the metastore.
+          The credential name. The name must be unique among storage and service credentials within the
+          metastore.
         :param aws_iam_role: :class:`AwsIamRoleRequest` (optional)
           The AWS IAM role configuration.
         :param azure_managed_identity: :class:`AzureManagedIdentityRequest` (optional)
@@ -13946,7 +15349,8 @@ class StorageCredentialsAPI:
         :param databricks_gcp_service_account: :class:`DatabricksGcpServiceAccountRequest` (optional)
           The Databricks managed GCP service account configuration.
         :param read_only: bool (optional)
-          Whether the storage credential is only usable for read operations.
+          Whether the credential is usable only for read operations. Only applicable when purpose is
+          **STORAGE**.
         :param skip_validation: bool (optional)
           Supplying true to this argument skips validation of the created credential.
 
@@ -13980,15 +15384,14 @@ class StorageCredentialsAPI:
         return StorageCredentialInfo.from_dict(res)
 
     def delete(self, name: str, *, force: Optional[bool] = None):
-        """Delete a credential.
-
-        Deletes a storage credential from the metastore. The caller must be an owner of the storage
+        """Deletes a storage credential from the metastore. The caller must be an owner of the storage
         credential.
 
         :param name: str
           Name of the storage credential.
         :param force: bool (optional)
-          Force deletion even if there are dependent external locations or external tables.
+          Force an update even if there are dependent external locations or external tables (when purpose is
+          **STORAGE**) or dependent services (when purpose is **SERVICE**).
 
 
         """
@@ -14003,9 +15406,7 @@ class StorageCredentialsAPI:
         self._api.do("DELETE", f"/api/2.1/unity-catalog/storage-credentials/{name}", query=query, headers=headers)
 
     def get(self, name: str) -> StorageCredentialInfo:
-        """Get a credential.
-
-        Gets a storage credential from the metastore. The caller must be a metastore admin, the owner of the
+        """Gets a storage credential from the metastore. The caller must be a metastore admin, the owner of the
         storage credential, or have some permission on the storage credential.
 
         :param name: str
@@ -14024,9 +15425,7 @@ class StorageCredentialsAPI:
     def list(
         self, *, max_results: Optional[int] = None, page_token: Optional[str] = None
     ) -> Iterator[StorageCredentialInfo]:
-        """List credentials.
-
-        Gets an array of storage credentials (as __StorageCredentialInfo__ objects). The array is limited to
+        """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.
@@ -14052,8 +15451,6 @@ class StorageCredentialsAPI:
             "Accept": "application/json",
         }
 
-        if "max_results" not in query:
-            query["max_results"] = 0
         while True:
             json = self._api.do("GET", "/api/2.1/unity-catalog/storage-credentials", query=query, headers=headers)
             if "storage_credentials" in json:
@@ -14080,9 +15477,10 @@ class StorageCredentialsAPI:
         read_only: Optional[bool] = None,
         skip_validation: Optional[bool] = None,
     ) -> StorageCredentialInfo:
-        """Update a credential.
+        """Updates a storage credential on the metastore.
 
-        Updates a storage credential on the metastore.
+        The caller must be the owner of the storage credential or a metastore admin. If the caller is a
+        metastore admin, only the **owner** field can be changed.
 
         :param name: str
           Name of the storage credential.
@@ -14101,12 +15499,14 @@ class StorageCredentialsAPI:
         :param force: bool (optional)
           Force update even if there are dependent external locations or external tables.
         :param isolation_mode: :class:`IsolationMode` (optional)
+          Whether the current securable is accessible from all workspaces or a specific set of workspaces.
         :param new_name: str (optional)
           New name for the storage credential.
         :param owner: str (optional)
           Username of current owner of credential.
         :param read_only: bool (optional)
-          Whether the storage credential is only usable for read operations.
+          Whether the credential is usable only for read operations. Only applicable when purpose is
+          **STORAGE**.
         :param skip_validation: bool (optional)
           Supplying true to this argument skips validation of the updated credential.
 
@@ -14158,9 +15558,7 @@ class StorageCredentialsAPI:
         storage_credential_name: Optional[str] = None,
         url: Optional[str] = None,
     ) -> ValidateStorageCredentialResponse:
-        """Validate a storage credential.
-
-        Validates a storage credential. At least one of __external_location_name__ and __url__ need to be
+        """Validates a storage credential. At least one of __external_location_name__ and __url__ need to be
         provided. If only one of them is provided, it will be used for validation. And if both are provided,
         the __url__ will be used for validation, and __external_location_name__ will be ignored when checking
         overlapping urls.
@@ -14185,7 +15583,7 @@ class StorageCredentialsAPI:
         :param read_only: bool (optional)
           Whether the storage credential is only usable for read operations.
         :param storage_credential_name: str (optional)
-          The name of the storage credential to validate.
+          Required. The name of an existing credential or long-lived cloud credential to validate.
         :param url: str (optional)
           The external location url to validate.
 
@@ -14227,9 +15625,7 @@ class SystemSchemasAPI:
         self._api = api_client
 
     def disable(self, metastore_id: str, schema_name: str):
-        """Disable a system schema.
-
-        Disables the system schema and removes it from the system catalog. The caller must be an account admin
+        """Disables the system schema and removes it from the system catalog. The caller must be an account admin
         or a metastore admin.
 
         :param metastore_id: str
@@ -14249,9 +15645,7 @@ class SystemSchemasAPI:
         )
 
     def enable(self, metastore_id: str, schema_name: str, *, catalog_name: Optional[str] = None):
-        """Enable a system schema.
-
-        Enables the system schema and adds it to the system catalog. The caller must be an account admin or a
+        """Enables the system schema and adds it to the system catalog. The caller must be an account admin or a
         metastore admin.
 
         :param metastore_id: str
@@ -14281,9 +15675,7 @@ class SystemSchemasAPI:
     def list(
         self, metastore_id: str, *, max_results: Optional[int] = None, page_token: Optional[str] = None
     ) -> Iterator[SystemSchemaInfo]:
-        """List system schemas.
-
-        Gets an array of system schemas for a metastore. The caller must be an account admin or a metastore
+        """Gets an array of system schemas for a metastore. The caller must be an account admin or a metastore
         admin.
 
         :param metastore_id: str
@@ -14336,9 +15728,7 @@ class TableConstraintsAPI:
         self._api = api_client
 
     def create(self, full_name_arg: str, constraint: TableConstraint) -> TableConstraint:
-        """Create a table constraint.
-
-        Creates a new table constraint.
+        """Creates a new table constraint.
 
         For the table constraint creation to succeed, the user must satisfy both of these conditions: - the
         user must have the **USE_CATALOG** privilege on the table's parent catalog, the **USE_SCHEMA**
@@ -14350,8 +15740,6 @@ class TableConstraintsAPI:
         :param full_name_arg: str
           The full name of the table referenced by the constraint.
         :param constraint: :class:`TableConstraint`
-          A table constraint, as defined by *one* of the following fields being set:
-          __primary_key_constraint__, __foreign_key_constraint__, __named_table_constraint__.
 
         :returns: :class:`TableConstraint`
         """
@@ -14369,9 +15757,7 @@ class TableConstraintsAPI:
         return TableConstraint.from_dict(res)
 
     def delete(self, full_name: str, constraint_name: str, cascade: bool):
-        """Delete a table constraint.
-
-        Deletes a table constraint.
+        """Deletes a table constraint.
 
         For the table constraint deletion to succeed, the user must satisfy both of these conditions: - the
         user must have the **USE_CATALOG** privilege on the table's parent catalog, the **USE_SCHEMA**
@@ -14417,9 +15803,7 @@ class TablesAPI:
         self._api = api_client
 
     def delete(self, full_name: str):
-        """Delete a table.
-
-        Deletes a table from the specified parent catalog and schema. The caller must be the owner of the
+        """Deletes a table from the specified parent catalog and schema. The caller must be the owner of the
         parent catalog, have the **USE_CATALOG** privilege on the parent catalog and be the owner of the
         parent schema, or be the owner of the table and have the **USE_CATALOG** privilege on the parent
         catalog and the **USE_SCHEMA** privilege on the parent schema.
@@ -14437,9 +15821,7 @@ class TablesAPI:
         self._api.do("DELETE", f"/api/2.1/unity-catalog/tables/{full_name}", headers=headers)
 
     def exists(self, full_name: str) -> TableExistsResponse:
-        """Get boolean reflecting if table exists.
-
-        Gets if a table exists in the metastore for a specific catalog and schema. The caller must satisfy one
+        """Gets if a table exists in the metastore for a specific catalog and schema. The caller must satisfy one
         of the following requirements: * Be a metastore admin * Be the owner of the parent catalog * Be the
         owner of the parent schema and have the USE_CATALOG privilege on the parent catalog * Have the
         **USE_CATALOG** privilege on the parent catalog and the **USE_SCHEMA** privilege on the parent schema,
@@ -14467,9 +15849,7 @@ class TablesAPI:
         include_delta_metadata: Optional[bool] = None,
         include_manifest_capabilities: Optional[bool] = None,
     ) -> TableInfo:
-        """Get a table.
-
-        Gets a table from the metastore for a specific catalog and schema. The caller must satisfy one of the
+        """Gets a table from the metastore for a specific catalog and schema. The caller must satisfy one of the
         following requirements: * Be a metastore admin * Be the owner of the parent catalog * Be the owner of
         the parent schema and have the USE_CATALOG privilege on the parent catalog * Have the **USE_CATALOG**
         privilege on the parent catalog and the **USE_SCHEMA** privilege on the parent schema, and either be
@@ -14479,11 +15859,11 @@ class TablesAPI:
           Full name of the table.
         :param include_browse: bool (optional)
           Whether to include tables in the response for which the principal can only access selective metadata
-          for
+          for.
         :param include_delta_metadata: bool (optional)
           Whether delta metadata should be included in the response.
         :param include_manifest_capabilities: bool (optional)
-          Whether to include a manifest containing capabilities the table has.
+          Whether to include a manifest containing table capabilities in the response.
 
         :returns: :class:`TableInfo`
         """
@@ -14508,7 +15888,6 @@ class TablesAPI:
         schema_name: str,
         *,
         include_browse: Optional[bool] = None,
-        include_delta_metadata: Optional[bool] = None,
         include_manifest_capabilities: Optional[bool] = None,
         max_results: Optional[int] = None,
         omit_columns: Optional[bool] = None,
@@ -14516,9 +15895,7 @@ class TablesAPI:
         omit_username: Optional[bool] = None,
         page_token: Optional[str] = None,
     ) -> Iterator[TableInfo]:
-        """List tables.
-
-        Gets an array of all tables for the current metastore under the parent catalog and schema. The caller
+        """Gets an array of all tables for the current metastore under the parent catalog and schema. The caller
         must be a metastore admin or an owner of (or have the **SELECT** privilege on) the table. For the
         latter case, the caller must also be the owner or have the **USE_CATALOG** privilege on the parent
         catalog and the **USE_SCHEMA** privilege on the parent schema. There is no guarantee of a specific
@@ -14530,11 +15907,9 @@ class TablesAPI:
           Parent schema of tables.
         :param include_browse: bool (optional)
           Whether to include tables in the response for which the principal can only access selective metadata
-          for
-        :param include_delta_metadata: bool (optional)
-          Whether delta metadata should be included in the response.
+          for.
         :param include_manifest_capabilities: bool (optional)
-          Whether to include a manifest containing capabilities the table has.
+          Whether to include a manifest containing table capabilities in the response.
         :param max_results: int (optional)
           Maximum number of tables to return. If not set, all the tables are returned (not recommended). -
           when set to a value greater than 0, the page length is the minimum of this value and a server
@@ -14558,8 +15933,6 @@ class TablesAPI:
             query["catalog_name"] = catalog_name
         if include_browse is not None:
             query["include_browse"] = include_browse
-        if include_delta_metadata is not None:
-            query["include_delta_metadata"] = include_delta_metadata
         if include_manifest_capabilities is not None:
             query["include_manifest_capabilities"] = include_manifest_capabilities
         if max_results is not None:
@@ -14578,8 +15951,6 @@ class TablesAPI:
             "Accept": "application/json",
         }
 
-        if "max_results" not in query:
-            query["max_results"] = 0
         while True:
             json = self._api.do("GET", "/api/2.1/unity-catalog/tables", query=query, headers=headers)
             if "tables" in json:
@@ -14599,9 +15970,7 @@ class TablesAPI:
         schema_name_pattern: Optional[str] = None,
         table_name_pattern: Optional[str] = None,
     ) -> Iterator[TableSummary]:
-        """List table summaries.
-
-        Gets an array of summaries for tables for a schema and catalog within the metastore. The table
+        """Gets an array of summaries for tables for a schema and catalog within the metastore. The table
         summaries returned are either:
 
         * summaries for tables (within the current metastore and parent catalog and schema), when the user is
@@ -14615,7 +15984,7 @@ class TablesAPI:
         :param catalog_name: str
           Name of parent catalog for tables of interest.
         :param include_manifest_capabilities: bool (optional)
-          Whether to include a manifest containing capabilities the table has.
+          Whether to include a manifest containing table capabilities in the response.
         :param max_results: int (optional)
           Maximum number of summaries for tables to return. If not set, the page length is set to a server
           configured value (10000, as of 1/5/2024). - when set to a value greater than 0, the page length is
@@ -14649,8 +16018,6 @@ class TablesAPI:
             "Accept": "application/json",
         }
 
-        if "max_results" not in query:
-            query["max_results"] = 0
         while True:
             json = self._api.do("GET", "/api/2.1/unity-catalog/table-summaries", query=query, headers=headers)
             if "tables" in json:
@@ -14661,9 +16028,7 @@ class TablesAPI:
             query["page_token"] = json["next_page_token"]
 
     def update(self, full_name: str, *, owner: Optional[str] = None):
-        """Update a table owner.
-
-        Change the owner of the table. The caller must be the owner of the parent catalog, have the
+        """Change the owner of the table. The caller must be the owner of the parent catalog, have the
         **USE_CATALOG** privilege on the parent catalog and be the owner of the parent schema, or be the owner
         of the table and have the **USE_CATALOG** privilege on the parent catalog and the **USE_SCHEMA**
         privilege on the parent schema.
@@ -14671,6 +16036,7 @@ class TablesAPI:
         :param full_name: str
           Full name of the table.
         :param owner: str (optional)
+          Username of current owner of table.
 
 
         """
@@ -14705,9 +16071,7 @@ class TemporaryTableCredentialsAPI:
     def generate_temporary_table_credentials(
         self, *, operation: Optional[TableOperation] = None, table_id: Optional[str] = None
     ) -> GenerateTemporaryTableCredentialResponse:
-        """Generate a temporary table credential.
-
-        Get a short-lived credential for directly accessing the table data on cloud storage. The metastore
+        """Get a short-lived credential for directly accessing the table data on cloud storage. The metastore
         must have external_access_enabled flag set to true (default false). The caller must have
         EXTERNAL_USE_SCHEMA privilege on the parent schema and this privilege can only be granted by catalog
         owners.
@@ -14755,9 +16119,7 @@ class VolumesAPI:
         comment: Optional[str] = None,
         storage_location: Optional[str] = None,
     ) -> VolumeInfo:
-        """Create a Volume.
-
-        Creates a new volume.
+        """Creates a new volume.
 
         The user could create either an external volume or a managed volume. An external volume will be
         created in the specified external location, while a managed volume will be located in the default
@@ -14780,11 +16142,6 @@ class VolumesAPI:
         :param name: str
           The name of the volume
         :param volume_type: :class:`VolumeType`
-          The type of the volume. An external volume is located in the specified external location. A managed
-          volume is located in the default location which is specified by the parent schema, or the parent
-          catalog, or the Metastore. [Learn more]
-
-          [Learn more]: https://docs.databricks.com/aws/en/volumes/managed-vs-external
         :param comment: str (optional)
           The comment attached to the volume
         :param storage_location: str (optional)
@@ -14814,9 +16171,7 @@ class VolumesAPI:
         return VolumeInfo.from_dict(res)
 
     def delete(self, name: str):
-        """Delete a Volume.
-
-        Deletes a volume from the specified parent catalog and schema.
+        """Deletes a volume from the specified parent catalog and schema.
 
         The caller must be a metastore admin or an owner of the volume. For the latter case, the caller must
         also be the owner or have the **USE_CATALOG** privilege on the parent catalog and the **USE_SCHEMA**
@@ -14841,9 +16196,7 @@ class VolumesAPI:
         max_results: Optional[int] = None,
         page_token: Optional[str] = None,
     ) -> Iterator[VolumeInfo]:
-        """List Volumes.
-
-        Gets an array of volumes for the current metastore under the parent catalog and schema.
+        """Gets an array of volumes for the current metastore under the parent catalog and schema.
 
         The returned volumes are filtered based on the privileges of the calling user. For example, the
         metastore admin is able to list all the volumes. A regular user needs to be the owner or have the
@@ -14904,9 +16257,7 @@ class VolumesAPI:
             query["page_token"] = json["next_page_token"]
 
     def read(self, name: str, *, include_browse: Optional[bool] = None) -> VolumeInfo:
-        """Get a Volume.
-
-        Gets a volume from the metastore for a specific catalog and schema.
+        """Gets a volume from the metastore for a specific catalog and schema.
 
         The caller must be a metastore admin or an owner of (or have the **READ VOLUME** privilege on) the
         volume. For the latter case, the caller must also be the owner or have the **USE_CATALOG** privilege
@@ -14934,9 +16285,7 @@ class VolumesAPI:
     def update(
         self, name: str, *, comment: Optional[str] = None, new_name: Optional[str] = None, owner: Optional[str] = None
     ) -> VolumeInfo:
-        """Update a Volume.
-
-        Updates the specified volume under the specified parent catalog and schema.
+        """Updates the specified volume under the specified parent catalog and schema.
 
         The caller must be a metastore admin or an owner of the volume. For the latter case, the caller must
         also be the owner or have the **USE_CATALOG** privilege on the parent catalog and the **USE_SCHEMA**
@@ -14991,9 +16340,7 @@ class WorkspaceBindingsAPI:
         self._api = api_client
 
     def get(self, name: str) -> GetCatalogWorkspaceBindingsResponse:
-        """Get catalog workspace bindings.
-
-        Gets workspace bindings of the catalog. The caller must be a metastore admin or an owner of the
+        """Gets workspace bindings of the catalog. The caller must be a metastore admin or an owner of the
         catalog.
 
         :param name: str
@@ -15017,9 +16364,7 @@ class WorkspaceBindingsAPI:
         max_results: Optional[int] = None,
         page_token: Optional[str] = None,
     ) -> Iterator[WorkspaceBinding]:
-        """Get securable workspace bindings.
-
-        Gets workspace bindings of the securable. The caller must be a metastore admin or an owner of the
+        """Gets workspace bindings of the securable. The caller must be a metastore admin or an owner of the
         securable.
 
         :param securable_type: str
@@ -15068,9 +16413,7 @@ class WorkspaceBindingsAPI:
         assign_workspaces: Optional[List[int]] = None,
         unassign_workspaces: Optional[List[int]] = None,
     ) -> UpdateCatalogWorkspaceBindingsResponse:
-        """Update catalog workspace bindings.
-
-        Updates workspace bindings of the catalog. The caller must be a metastore admin or an owner of the
+        """Updates workspace bindings of the catalog. The caller must be a metastore admin or an owner of the
         catalog.
 
         :param name: str
@@ -15105,9 +16448,7 @@ class WorkspaceBindingsAPI:
         add: Optional[List[WorkspaceBinding]] = None,
         remove: Optional[List[WorkspaceBinding]] = None,
     ) -> UpdateWorkspaceBindingsResponse:
-        """Update securable workspace bindings.
-
-        Updates workspace bindings of the securable. The caller must be a metastore admin or an owner of the
+        """Updates workspace bindings of the securable. The caller must be a metastore admin or an owner of the
         securable.
 
         :param securable_type: str