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

databricks/sdk/service/catalog.py

@@ -28,6 +28,12 @@ class AccountsCreateMetastore:
         if self.metastore_info: body['metastore_info'] = self.metastore_info.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AccountsCreateMetastore into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.metastore_info: body['metastore_info'] = self.metastore_info
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AccountsCreateMetastore:
         """Deserializes the AccountsCreateMetastore from a dictionary."""
@@ -52,6 +58,14 @@ class AccountsCreateMetastoreAssignment:
         if self.workspace_id is not None: body['workspace_id'] = self.workspace_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AccountsCreateMetastoreAssignment into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.metastore_assignment: body['metastore_assignment'] = self.metastore_assignment
+        if self.metastore_id is not None: body['metastore_id'] = self.metastore_id
+        if self.workspace_id is not None: body['workspace_id'] = self.workspace_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AccountsCreateMetastoreAssignment:
         """Deserializes the AccountsCreateMetastoreAssignment from a dictionary."""
@@ -74,6 +88,13 @@ class AccountsCreateStorageCredential:
         if self.metastore_id is not None: body['metastore_id'] = self.metastore_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AccountsCreateStorageCredential into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.credential_info: body['credential_info'] = self.credential_info
+        if self.metastore_id is not None: body['metastore_id'] = self.metastore_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AccountsCreateStorageCredential:
         """Deserializes the AccountsCreateStorageCredential from a dictionary."""
@@ -91,6 +112,12 @@ class AccountsMetastoreAssignment:
         if self.metastore_assignment: body['metastore_assignment'] = self.metastore_assignment.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AccountsMetastoreAssignment into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.metastore_assignment: body['metastore_assignment'] = self.metastore_assignment
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AccountsMetastoreAssignment:
         """Deserializes the AccountsMetastoreAssignment from a dictionary."""
@@ -107,6 +134,12 @@ class AccountsMetastoreInfo:
         if self.metastore_info: body['metastore_info'] = self.metastore_info.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AccountsMetastoreInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.metastore_info: body['metastore_info'] = self.metastore_info
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AccountsMetastoreInfo:
         """Deserializes the AccountsMetastoreInfo from a dictionary."""
@@ -123,6 +156,12 @@ class AccountsStorageCredentialInfo:
         if self.credential_info: body['credential_info'] = self.credential_info.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AccountsStorageCredentialInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.credential_info: body['credential_info'] = self.credential_info
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AccountsStorageCredentialInfo:
         """Deserializes the AccountsStorageCredentialInfo from a dictionary."""
@@ -143,6 +182,13 @@ class AccountsUpdateMetastore:
         if self.metastore_info: body['metastore_info'] = self.metastore_info.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AccountsUpdateMetastore into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.metastore_id is not None: body['metastore_id'] = self.metastore_id
+        if self.metastore_info: body['metastore_info'] = self.metastore_info
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AccountsUpdateMetastore:
         """Deserializes the AccountsUpdateMetastore from a dictionary."""
@@ -168,6 +214,14 @@ class AccountsUpdateMetastoreAssignment:
         if self.workspace_id is not None: body['workspace_id'] = self.workspace_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AccountsUpdateMetastoreAssignment into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.metastore_assignment: body['metastore_assignment'] = self.metastore_assignment
+        if self.metastore_id is not None: body['metastore_id'] = self.metastore_id
+        if self.workspace_id is not None: body['workspace_id'] = self.workspace_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AccountsUpdateMetastoreAssignment:
         """Deserializes the AccountsUpdateMetastoreAssignment from a dictionary."""
@@ -195,6 +249,15 @@ class AccountsUpdateStorageCredential:
             body['storage_credential_name'] = self.storage_credential_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AccountsUpdateStorageCredential into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.credential_info: body['credential_info'] = self.credential_info
+        if self.metastore_id is not None: body['metastore_id'] = self.metastore_id
+        if self.storage_credential_name is not None:
+            body['storage_credential_name'] = self.storage_credential_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AccountsUpdateStorageCredential:
         """Deserializes the AccountsUpdateStorageCredential from a dictionary."""
@@ -226,6 +289,15 @@ class ArtifactAllowlistInfo:
         if self.metastore_id is not None: body['metastore_id'] = self.metastore_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ArtifactAllowlistInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.artifact_matchers: body['artifact_matchers'] = self.artifact_matchers
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.created_by is not None: body['created_by'] = self.created_by
+        if self.metastore_id is not None: body['metastore_id'] = self.metastore_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ArtifactAllowlistInfo:
         """Deserializes the ArtifactAllowlistInfo from a dictionary."""
@@ -250,6 +322,13 @@ class ArtifactMatcher:
         if self.match_type is not None: body['match_type'] = self.match_type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ArtifactMatcher into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.artifact is not None: body['artifact'] = self.artifact
+        if self.match_type is not None: body['match_type'] = self.match_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ArtifactMatcher:
         """Deserializes the ArtifactMatcher from a dictionary."""
@@ -272,6 +351,11 @@ class AssignResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AssignResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AssignResponse:
         """Deserializes the AssignResponse from a dictionary."""
@@ -305,6 +389,15 @@ class AwsCredentials:
         if self.session_token is not None: body['session_token'] = self.session_token
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AwsCredentials into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.access_key_id is not None: body['access_key_id'] = self.access_key_id
+        if self.access_point is not None: body['access_point'] = self.access_point
+        if self.secret_access_key is not None: body['secret_access_key'] = self.secret_access_key
+        if self.session_token is not None: body['session_token'] = self.session_token
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AwsCredentials:
         """Deserializes the AwsCredentials from a dictionary."""
@@ -336,6 +429,14 @@ class AwsIamRole:
         if self.unity_catalog_iam_arn is not None: body['unity_catalog_iam_arn'] = self.unity_catalog_iam_arn
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AwsIamRole into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.external_id is not None: body['external_id'] = self.external_id
+        if self.role_arn is not None: body['role_arn'] = self.role_arn
+        if self.unity_catalog_iam_arn is not None: body['unity_catalog_iam_arn'] = self.unity_catalog_iam_arn
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AwsIamRole:
         """Deserializes the AwsIamRole from a dictionary."""
@@ -355,6 +456,12 @@ class AwsIamRoleRequest:
         if self.role_arn is not None: body['role_arn'] = self.role_arn
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AwsIamRoleRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.role_arn is not None: body['role_arn'] = self.role_arn
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AwsIamRoleRequest:
         """Deserializes the AwsIamRoleRequest from a dictionary."""
@@ -381,6 +488,14 @@ class AwsIamRoleResponse:
         if self.unity_catalog_iam_arn is not None: body['unity_catalog_iam_arn'] = self.unity_catalog_iam_arn
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AwsIamRoleResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.external_id is not None: body['external_id'] = self.external_id
+        if self.role_arn is not None: body['role_arn'] = self.role_arn
+        if self.unity_catalog_iam_arn is not None: body['unity_catalog_iam_arn'] = self.unity_catalog_iam_arn
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AwsIamRoleResponse:
         """Deserializes the AwsIamRoleResponse from a dictionary."""
@@ -405,6 +520,12 @@ class AzureActiveDirectoryToken:
         if self.aad_token is not None: body['aad_token'] = self.aad_token
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AzureActiveDirectoryToken into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.aad_token is not None: body['aad_token'] = self.aad_token
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AzureActiveDirectoryToken:
         """Deserializes the AzureActiveDirectoryToken from a dictionary."""
@@ -415,7 +536,7 @@ class AzureActiveDirectoryToken:
 class AzureManagedIdentity:
     """The Azure managed identity configuration."""
 
-    access_connector_id: Optional[str] = None
+    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}`."""
 
@@ -439,6 +560,14 @@ class AzureManagedIdentity:
         if self.managed_identity_id is not None: body['managed_identity_id'] = self.managed_identity_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AzureManagedIdentity into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.access_connector_id is not None: body['access_connector_id'] = self.access_connector_id
+        if self.credential_id is not None: body['credential_id'] = self.credential_id
+        if self.managed_identity_id is not None: body['managed_identity_id'] = self.managed_identity_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AzureManagedIdentity:
         """Deserializes the AzureManagedIdentity from a dictionary."""
@@ -467,6 +596,13 @@ class AzureManagedIdentityRequest:
         if self.managed_identity_id is not None: body['managed_identity_id'] = self.managed_identity_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AzureManagedIdentityRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.access_connector_id is not None: body['access_connector_id'] = self.access_connector_id
+        if self.managed_identity_id is not None: body['managed_identity_id'] = self.managed_identity_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AzureManagedIdentityRequest:
         """Deserializes the AzureManagedIdentityRequest from a dictionary."""
@@ -498,6 +634,14 @@ class AzureManagedIdentityResponse:
         if self.managed_identity_id is not None: body['managed_identity_id'] = self.managed_identity_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AzureManagedIdentityResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.access_connector_id is not None: body['access_connector_id'] = self.access_connector_id
+        if self.credential_id is not None: body['credential_id'] = self.credential_id
+        if self.managed_identity_id is not None: body['managed_identity_id'] = self.managed_identity_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AzureManagedIdentityResponse:
         """Deserializes the AzureManagedIdentityResponse from a dictionary."""
@@ -508,6 +652,8 @@ class AzureManagedIdentityResponse:
 
 @dataclass
 class AzureServicePrincipal:
+    """The Azure service principal configuration. Only applicable when purpose is **STORAGE**."""
+
     directory_id: str
     """The directory ID corresponding to the Azure Active Directory (AAD) tenant of the application."""
 
@@ -525,6 +671,14 @@ class AzureServicePrincipal:
         if self.directory_id is not None: body['directory_id'] = self.directory_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AzureServicePrincipal into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.application_id is not None: body['application_id'] = self.application_id
+        if self.client_secret is not None: body['client_secret'] = self.client_secret
+        if self.directory_id is not None: body['directory_id'] = self.directory_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AzureServicePrincipal:
         """Deserializes the AzureServicePrincipal from a dictionary."""
@@ -547,6 +701,12 @@ class AzureUserDelegationSas:
         if self.sas_token is not None: body['sas_token'] = self.sas_token
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the AzureUserDelegationSas into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.sas_token is not None: body['sas_token'] = self.sas_token
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> AzureUserDelegationSas:
         """Deserializes the AzureUserDelegationSas from a dictionary."""
@@ -561,6 +721,11 @@ class CancelRefreshResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CancelRefreshResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CancelRefreshResponse:
         """Deserializes the CancelRefreshResponse from a dictionary."""
@@ -675,6 +840,37 @@ class CatalogInfo:
         if self.updated_by is not None: body['updated_by'] = self.updated_by
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CatalogInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.browse_only is not None: body['browse_only'] = self.browse_only
+        if self.catalog_type is not None: body['catalog_type'] = self.catalog_type
+        if self.comment is not None: body['comment'] = self.comment
+        if self.connection_name is not None: body['connection_name'] = self.connection_name
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.created_by is not None: body['created_by'] = self.created_by
+        if self.effective_predictive_optimization_flag:
+            body['effective_predictive_optimization_flag'] = self.effective_predictive_optimization_flag
+        if self.enable_predictive_optimization is not None:
+            body['enable_predictive_optimization'] = self.enable_predictive_optimization
+        if self.full_name is not None: body['full_name'] = self.full_name
+        if self.isolation_mode is not None: body['isolation_mode'] = self.isolation_mode
+        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.options: body['options'] = self.options
+        if self.owner is not None: body['owner'] = self.owner
+        if self.properties: body['properties'] = self.properties
+        if self.provider_name is not None: body['provider_name'] = self.provider_name
+        if self.provisioning_info: body['provisioning_info'] = self.provisioning_info
+        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
+        if self.share_name is not None: body['share_name'] = self.share_name
+        if self.storage_location is not None: body['storage_location'] = self.storage_location
+        if self.storage_root is not None: body['storage_root'] = self.storage_root
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.updated_by is not None: body['updated_by'] = self.updated_by
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CatalogInfo:
         """Deserializes the CatalogInfo from a dictionary."""
@@ -758,6 +954,14 @@ class CloudflareApiToken:
         if self.secret_access_key is not None: body['secret_access_key'] = self.secret_access_key
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CloudflareApiToken into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.access_key_id is not None: body['access_key_id'] = self.access_key_id
+        if self.account_id is not None: body['account_id'] = self.account_id
+        if self.secret_access_key is not None: body['secret_access_key'] = self.secret_access_key
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CloudflareApiToken:
         """Deserializes the CloudflareApiToken from a dictionary."""
@@ -792,7 +996,6 @@ class ColumnInfo:
     """Full data type specification, JSON-serialized."""
 
     type_name: Optional[ColumnTypeName] = None
-    """Name of type (INT, STRUCT, MAP, etc.)."""
 
     type_precision: Optional[int] = None
     """Digits of precision; required for DecimalTypes."""
@@ -820,6 +1023,23 @@ class ColumnInfo:
         if self.type_text is not None: body['type_text'] = self.type_text
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ColumnInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.comment is not None: body['comment'] = self.comment
+        if self.mask: body['mask'] = self.mask
+        if self.name is not None: body['name'] = self.name
+        if self.nullable is not None: body['nullable'] = self.nullable
+        if self.partition_index is not None: body['partition_index'] = self.partition_index
+        if self.position is not None: body['position'] = self.position
+        if self.type_interval_type is not None: body['type_interval_type'] = self.type_interval_type
+        if self.type_json is not None: body['type_json'] = self.type_json
+        if self.type_name is not None: body['type_name'] = self.type_name
+        if self.type_precision is not None: body['type_precision'] = self.type_precision
+        if self.type_scale is not None: body['type_scale'] = self.type_scale
+        if self.type_text is not None: body['type_text'] = self.type_text
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ColumnInfo:
         """Deserializes the ColumnInfo from a dictionary."""
@@ -854,6 +1074,13 @@ class ColumnMask:
         if self.using_column_names: body['using_column_names'] = [v for v in self.using_column_names]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ColumnMask into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.function_name is not None: body['function_name'] = self.function_name
+        if self.using_column_names: body['using_column_names'] = self.using_column_names
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ColumnMask:
         """Deserializes the ColumnMask from a dictionary."""
@@ -862,7 +1089,6 @@ class ColumnMask:
 
 
 class ColumnTypeName(Enum):
-    """Name of type (INT, STRUCT, MAP, etc.)."""
 
     ARRAY = 'ARRAY'
     BINARY = 'BINARY'
@@ -970,6 +1196,30 @@ class ConnectionInfo:
         if self.url is not None: body['url'] = self.url
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ConnectionInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.comment is not None: body['comment'] = self.comment
+        if self.connection_id is not None: body['connection_id'] = self.connection_id
+        if self.connection_type is not None: body['connection_type'] = self.connection_type
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.created_by is not None: body['created_by'] = self.created_by
+        if self.credential_type is not None: body['credential_type'] = self.credential_type
+        if self.full_name is not None: body['full_name'] = self.full_name
+        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.options: body['options'] = self.options
+        if self.owner is not None: body['owner'] = self.owner
+        if self.properties: body['properties'] = self.properties
+        if self.provisioning_info: body['provisioning_info'] = self.provisioning_info
+        if self.read_only is not None: body['read_only'] = self.read_only
+        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
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.updated_by is not None: body['updated_by'] = self.updated_by
+        if self.url is not None: body['url'] = self.url
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ConnectionInfo:
         """Deserializes the ConnectionInfo from a dictionary."""
@@ -1054,6 +1304,16 @@ class ContinuousUpdateStatus:
         if self.timestamp is not None: body['timestamp'] = self.timestamp
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ContinuousUpdateStatus into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.initial_pipeline_sync_progress:
+            body['initial_pipeline_sync_progress'] = self.initial_pipeline_sync_progress
+        if self.last_processed_commit_version is not None:
+            body['last_processed_commit_version'] = self.last_processed_commit_version
+        if self.timestamp is not None: body['timestamp'] = self.timestamp
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ContinuousUpdateStatus:
         """Deserializes the ContinuousUpdateStatus from a dictionary."""
@@ -1104,6 +1364,19 @@ class CreateCatalog:
         if self.storage_root is not None: body['storage_root'] = self.storage_root
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateCatalog into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.comment is not None: body['comment'] = self.comment
+        if self.connection_name is not None: body['connection_name'] = self.connection_name
+        if self.name is not None: body['name'] = self.name
+        if self.options: body['options'] = self.options
+        if self.properties: body['properties'] = self.properties
+        if self.provider_name is not None: body['provider_name'] = self.provider_name
+        if self.share_name is not None: body['share_name'] = self.share_name
+        if self.storage_root is not None: body['storage_root'] = self.storage_root
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateCatalog:
         """Deserializes the CreateCatalog from a dictionary."""
@@ -1148,6 +1421,17 @@ class CreateConnection:
         if self.read_only is not None: body['read_only'] = self.read_only
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateConnection into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.comment is not None: body['comment'] = self.comment
+        if self.connection_type is not None: body['connection_type'] = self.connection_type
+        if self.name is not None: body['name'] = self.name
+        if self.options: body['options'] = self.options
+        if self.properties: body['properties'] = self.properties
+        if self.read_only is not None: body['read_only'] = self.read_only
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateConnection:
         """Deserializes the CreateConnection from a dictionary."""
@@ -1161,22 +1445,32 @@ class CreateConnection:
 
 @dataclass
 class CreateCredentialRequest:
+    name: str
+    """The credential name. The name must be unique among storage and service credentials within the
+    metastore."""
+
     aws_iam_role: Optional[AwsIamRole] = None
     """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**."""
+
     comment: Optional[str] = None
     """Comment associated with the credential."""
 
-    name: Optional[str] = None
-    """The credential name. The name must be unique among storage and service credentials within the
-    metastore."""
+    databricks_gcp_service_account: Optional[DatabricksGcpServiceAccount] = None
+    """GCP long-lived credential. Databricks-created Google Cloud Storage service account."""
 
     purpose: Optional[CredentialPurpose] = None
     """Indicates the purpose of the credential."""
 
+    read_only: Optional[bool] = None
+    """Whether the credential is usable only for read operations. Only applicable when purpose is
+    **STORAGE**."""
+
     skip_validation: Optional[bool] = None
     """Optional. Supplying true to this argument skips validation of the created set of credentials."""
 
@@ -1185,9 +1479,29 @@ class CreateCredentialRequest:
         body = {}
         if self.aws_iam_role: body['aws_iam_role'] = self.aws_iam_role.as_dict()
         if self.azure_managed_identity: body['azure_managed_identity'] = self.azure_managed_identity.as_dict()
+        if self.azure_service_principal:
+            body['azure_service_principal'] = self.azure_service_principal.as_dict()
         if self.comment is not None: body['comment'] = self.comment
+        if self.databricks_gcp_service_account:
+            body['databricks_gcp_service_account'] = self.databricks_gcp_service_account.as_dict()
         if self.name is not None: body['name'] = self.name
         if self.purpose is not None: body['purpose'] = self.purpose.value
+        if self.read_only is not None: body['read_only'] = self.read_only
+        if self.skip_validation is not None: body['skip_validation'] = self.skip_validation
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateCredentialRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.aws_iam_role: body['aws_iam_role'] = self.aws_iam_role
+        if self.azure_managed_identity: body['azure_managed_identity'] = self.azure_managed_identity
+        if self.azure_service_principal: body['azure_service_principal'] = self.azure_service_principal
+        if self.comment is not None: body['comment'] = self.comment
+        if self.databricks_gcp_service_account:
+            body['databricks_gcp_service_account'] = self.databricks_gcp_service_account
+        if self.name is not None: body['name'] = self.name
+        if self.purpose is not None: body['purpose'] = self.purpose
+        if self.read_only is not None: body['read_only'] = self.read_only
         if self.skip_validation is not None: body['skip_validation'] = self.skip_validation
         return body
 
@@ -1196,9 +1510,13 @@ class CreateCredentialRequest:
         """Deserializes the CreateCredentialRequest from a dictionary."""
         return cls(aws_iam_role=_from_dict(d, 'aws_iam_role', AwsIamRole),
                    azure_managed_identity=_from_dict(d, 'azure_managed_identity', AzureManagedIdentity),
+                   azure_service_principal=_from_dict(d, 'azure_service_principal', AzureServicePrincipal),
                    comment=d.get('comment', None),
+                   databricks_gcp_service_account=_from_dict(d, 'databricks_gcp_service_account',
+                                                             DatabricksGcpServiceAccount),
                    name=d.get('name', None),
                    purpose=_enum(d, 'purpose', CredentialPurpose),
+                   read_only=d.get('read_only', None),
                    skip_validation=d.get('skip_validation', None))
 
 
@@ -1247,6 +1565,20 @@ class CreateExternalLocation:
         if self.url is not None: body['url'] = self.url
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateExternalLocation into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.access_point is not None: body['access_point'] = self.access_point
+        if self.comment is not None: body['comment'] = self.comment
+        if self.credential_name is not None: body['credential_name'] = self.credential_name
+        if self.encryption_details: body['encryption_details'] = self.encryption_details
+        if self.fallback is not None: body['fallback'] = self.fallback
+        if self.name is not None: body['name'] = self.name
+        if self.read_only is not None: body['read_only'] = self.read_only
+        if self.skip_validation is not None: body['skip_validation'] = self.skip_validation
+        if self.url is not None: body['url'] = self.url
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateExternalLocation:
         """Deserializes the CreateExternalLocation from a dictionary."""
@@ -1354,6 +1686,32 @@ class CreateFunction:
         if self.sql_path is not None: body['sql_path'] = self.sql_path
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateFunction into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.catalog_name is not None: body['catalog_name'] = self.catalog_name
+        if self.comment is not None: body['comment'] = self.comment
+        if self.data_type is not None: body['data_type'] = self.data_type
+        if self.external_language is not None: body['external_language'] = self.external_language
+        if self.external_name is not None: body['external_name'] = self.external_name
+        if self.full_data_type is not None: body['full_data_type'] = self.full_data_type
+        if self.input_params: body['input_params'] = self.input_params
+        if self.is_deterministic is not None: body['is_deterministic'] = self.is_deterministic
+        if self.is_null_call is not None: body['is_null_call'] = self.is_null_call
+        if self.name is not None: body['name'] = self.name
+        if self.parameter_style is not None: body['parameter_style'] = self.parameter_style
+        if self.properties is not None: body['properties'] = self.properties
+        if self.return_params: body['return_params'] = self.return_params
+        if self.routine_body is not None: body['routine_body'] = self.routine_body
+        if self.routine_definition is not None: body['routine_definition'] = self.routine_definition
+        if self.routine_dependencies: body['routine_dependencies'] = self.routine_dependencies
+        if self.schema_name is not None: body['schema_name'] = self.schema_name
+        if self.security_type is not None: body['security_type'] = self.security_type
+        if self.specific_name is not None: body['specific_name'] = self.specific_name
+        if self.sql_data_access is not None: body['sql_data_access'] = self.sql_data_access
+        if self.sql_path is not None: body['sql_path'] = self.sql_path
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateFunction:
         """Deserializes the CreateFunction from a dictionary."""
@@ -1397,6 +1755,12 @@ class CreateFunctionRequest:
         if self.function_info: body['function_info'] = self.function_info.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateFunctionRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.function_info: body['function_info'] = self.function_info
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateFunctionRequest:
         """Deserializes the CreateFunctionRequest from a dictionary."""
@@ -1448,6 +1812,14 @@ class CreateMetastore:
         if self.storage_root is not None: body['storage_root'] = self.storage_root
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateMetastore into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.name is not None: body['name'] = self.name
+        if self.region is not None: body['region'] = self.region
+        if self.storage_root is not None: body['storage_root'] = self.storage_root
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateMetastore:
         """Deserializes the CreateMetastore from a dictionary."""
@@ -1476,6 +1848,14 @@ class CreateMetastoreAssignment:
         if self.workspace_id is not None: body['workspace_id'] = self.workspace_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateMetastoreAssignment into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.default_catalog_name is not None: body['default_catalog_name'] = self.default_catalog_name
+        if self.metastore_id is not None: body['metastore_id'] = self.metastore_id
+        if self.workspace_id is not None: body['workspace_id'] = self.workspace_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateMetastoreAssignment:
         """Deserializes the CreateMetastoreAssignment from a dictionary."""
@@ -1555,6 +1935,27 @@ class CreateMonitor:
         if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateMonitor into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.assets_dir is not None: body['assets_dir'] = self.assets_dir
+        if self.baseline_table_name is not None: body['baseline_table_name'] = self.baseline_table_name
+        if self.custom_metrics: body['custom_metrics'] = self.custom_metrics
+        if self.data_classification_config:
+            body['data_classification_config'] = self.data_classification_config
+        if self.inference_log: body['inference_log'] = self.inference_log
+        if self.notifications: body['notifications'] = self.notifications
+        if self.output_schema_name is not None: body['output_schema_name'] = self.output_schema_name
+        if self.schedule: body['schedule'] = self.schedule
+        if self.skip_builtin_dashboard is not None:
+            body['skip_builtin_dashboard'] = self.skip_builtin_dashboard
+        if self.slicing_exprs: body['slicing_exprs'] = self.slicing_exprs
+        if self.snapshot: body['snapshot'] = self.snapshot
+        if self.table_name is not None: body['table_name'] = self.table_name
+        if self.time_series: body['time_series'] = self.time_series
+        if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateMonitor:
         """Deserializes the CreateMonitor from a dictionary."""
@@ -1602,6 +2003,16 @@ class CreateRegisteredModelRequest:
         if self.storage_location is not None: body['storage_location'] = self.storage_location
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateRegisteredModelRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.catalog_name is not None: body['catalog_name'] = self.catalog_name
+        if self.comment is not None: body['comment'] = self.comment
+        if self.name is not None: body['name'] = self.name
+        if self.schema_name is not None: body['schema_name'] = self.schema_name
+        if self.storage_location is not None: body['storage_location'] = self.storage_location
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateRegisteredModelRequest:
         """Deserializes the CreateRegisteredModelRequest from a dictionary."""
@@ -1620,6 +2031,11 @@ class CreateResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateResponse:
         """Deserializes the CreateResponse from a dictionary."""
@@ -1653,6 +2069,16 @@ class CreateSchema:
         if self.storage_root is not None: body['storage_root'] = self.storage_root
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateSchema into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.catalog_name is not None: body['catalog_name'] = self.catalog_name
+        if self.comment is not None: body['comment'] = self.comment
+        if self.name is not None: body['name'] = self.name
+        if self.properties: body['properties'] = self.properties
+        if self.storage_root is not None: body['storage_root'] = self.storage_root
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateSchema:
         """Deserializes the CreateSchema from a dictionary."""
@@ -1708,6 +2134,21 @@ class CreateStorageCredential:
         if self.skip_validation is not None: body['skip_validation'] = self.skip_validation
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateStorageCredential into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.aws_iam_role: body['aws_iam_role'] = self.aws_iam_role
+        if self.azure_managed_identity: body['azure_managed_identity'] = self.azure_managed_identity
+        if self.azure_service_principal: body['azure_service_principal'] = self.azure_service_principal
+        if self.cloudflare_api_token: body['cloudflare_api_token'] = self.cloudflare_api_token
+        if self.comment is not None: body['comment'] = self.comment
+        if self.databricks_gcp_service_account:
+            body['databricks_gcp_service_account'] = self.databricks_gcp_service_account
+        if self.name is not None: body['name'] = self.name
+        if self.read_only is not None: body['read_only'] = self.read_only
+        if self.skip_validation is not None: body['skip_validation'] = self.skip_validation
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateStorageCredential:
         """Deserializes the CreateStorageCredential from a dictionary."""
@@ -1740,6 +2181,13 @@ class CreateTableConstraint:
         if self.full_name_arg is not None: body['full_name_arg'] = self.full_name_arg
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateTableConstraint into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.constraint: body['constraint'] = self.constraint
+        if self.full_name_arg is not None: body['full_name_arg'] = self.full_name_arg
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateTableConstraint:
         """Deserializes the CreateTableConstraint from a dictionary."""
@@ -1777,6 +2225,17 @@ class CreateVolumeRequestContent:
         if self.volume_type is not None: body['volume_type'] = self.volume_type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CreateVolumeRequestContent into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.catalog_name is not None: body['catalog_name'] = self.catalog_name
+        if self.comment is not None: body['comment'] = self.comment
+        if self.name is not None: body['name'] = self.name
+        if self.schema_name is not None: body['schema_name'] = self.schema_name
+        if self.storage_location is not None: body['storage_location'] = self.storage_location
+        if self.volume_type is not None: body['volume_type'] = self.volume_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CreateVolumeRequestContent:
         """Deserializes the CreateVolumeRequestContent from a dictionary."""
@@ -1796,6 +2255,9 @@ class CredentialInfo:
     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**."""
+
     comment: Optional[str] = None
     """Comment associated with the credential."""
 
@@ -1805,6 +2267,9 @@ class CredentialInfo:
     created_by: Optional[str] = None
     """Username of credential creator."""
 
+    databricks_gcp_service_account: Optional[DatabricksGcpServiceAccount] = None
+    """GCP long-lived credential. Databricks-created Google Cloud Storage service account."""
+
     full_name: Optional[str] = None
     """The full name of the credential."""
 
@@ -1827,20 +2292,32 @@ class CredentialInfo:
     purpose: Optional[CredentialPurpose] = None
     """Indicates the purpose of the credential."""
 
+    read_only: Optional[bool] = None
+    """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."""
 
     updated_by: Optional[str] = None
     """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. Only applicable when
+    purpose is **STORAGE**."""
+
     def as_dict(self) -> dict:
         """Serializes the CredentialInfo into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.aws_iam_role: body['aws_iam_role'] = self.aws_iam_role.as_dict()
         if self.azure_managed_identity: body['azure_managed_identity'] = self.azure_managed_identity.as_dict()
+        if self.azure_service_principal:
+            body['azure_service_principal'] = self.azure_service_principal.as_dict()
         if self.comment is not None: body['comment'] = self.comment
         if self.created_at is not None: body['created_at'] = self.created_at
         if self.created_by is not None: body['created_by'] = self.created_by
+        if self.databricks_gcp_service_account:
+            body['databricks_gcp_service_account'] = self.databricks_gcp_service_account.as_dict()
         if self.full_name is not None: body['full_name'] = self.full_name
         if self.id is not None: body['id'] = self.id
         if self.isolation_mode is not None: body['isolation_mode'] = self.isolation_mode.value
@@ -1848,8 +2325,36 @@ class CredentialInfo:
         if self.name is not None: body['name'] = self.name
         if self.owner is not None: body['owner'] = self.owner
         if self.purpose is not None: body['purpose'] = self.purpose.value
+        if self.read_only is not None: body['read_only'] = self.read_only
         if self.updated_at is not None: body['updated_at'] = self.updated_at
         if self.updated_by is not None: body['updated_by'] = self.updated_by
+        if self.used_for_managed_storage is not None:
+            body['used_for_managed_storage'] = self.used_for_managed_storage
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CredentialInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.aws_iam_role: body['aws_iam_role'] = self.aws_iam_role
+        if self.azure_managed_identity: body['azure_managed_identity'] = self.azure_managed_identity
+        if self.azure_service_principal: body['azure_service_principal'] = self.azure_service_principal
+        if self.comment is not None: body['comment'] = self.comment
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.created_by is not None: body['created_by'] = self.created_by
+        if self.databricks_gcp_service_account:
+            body['databricks_gcp_service_account'] = self.databricks_gcp_service_account
+        if self.full_name is not None: body['full_name'] = self.full_name
+        if self.id is not None: body['id'] = self.id
+        if self.isolation_mode is not None: body['isolation_mode'] = self.isolation_mode
+        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.purpose is not None: body['purpose'] = self.purpose
+        if self.read_only is not None: body['read_only'] = self.read_only
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.updated_by is not None: body['updated_by'] = self.updated_by
+        if self.used_for_managed_storage is not None:
+            body['used_for_managed_storage'] = self.used_for_managed_storage
         return body
 
     @classmethod
@@ -1857,9 +2362,12 @@ class CredentialInfo:
         """Deserializes the CredentialInfo from a dictionary."""
         return cls(aws_iam_role=_from_dict(d, 'aws_iam_role', AwsIamRole),
                    azure_managed_identity=_from_dict(d, 'azure_managed_identity', AzureManagedIdentity),
+                   azure_service_principal=_from_dict(d, 'azure_service_principal', AzureServicePrincipal),
                    comment=d.get('comment', None),
                    created_at=d.get('created_at', None),
                    created_by=d.get('created_by', None),
+                   databricks_gcp_service_account=_from_dict(d, 'databricks_gcp_service_account',
+                                                             DatabricksGcpServiceAccount),
                    full_name=d.get('full_name', None),
                    id=d.get('id', None),
                    isolation_mode=_enum(d, 'isolation_mode', IsolationMode),
@@ -1867,13 +2375,16 @@ class CredentialInfo:
                    name=d.get('name', None),
                    owner=d.get('owner', None),
                    purpose=_enum(d, 'purpose', CredentialPurpose),
+                   read_only=d.get('read_only', None),
                    updated_at=d.get('updated_at', None),
-                   updated_by=d.get('updated_by', None))
+                   updated_by=d.get('updated_by', None),
+                   used_for_managed_storage=d.get('used_for_managed_storage', None))
 
 
 class CredentialPurpose(Enum):
 
     SERVICE = 'SERVICE'
+    STORAGE = 'STORAGE'
 
 
 class CredentialType(Enum):
@@ -1898,6 +2409,13 @@ class CredentialValidationResult:
         if self.result is not None: body['result'] = self.result.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CredentialValidationResult into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.message is not None: body['message'] = self.message
+        if self.result is not None: body['result'] = self.result
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CredentialValidationResult:
         """Deserializes the CredentialValidationResult from a dictionary."""
@@ -1917,6 +2435,12 @@ class CurrentWorkspaceBindings:
         if self.workspaces: body['workspaces'] = [v for v in self.workspaces]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CurrentWorkspaceBindings into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.workspaces: body['workspaces'] = self.workspaces
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> CurrentWorkspaceBindings:
         """Deserializes the CurrentWorkspaceBindings from a dictionary."""
@@ -1951,6 +2475,45 @@ class DataSourceFormat(Enum):
     WORKDAY_RAAS_FORMAT = 'WORKDAY_RAAS_FORMAT'
 
 
+@dataclass
+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"""
+
+    email: Optional[str] = None
+    """The email of the service account."""
+
+    private_key_id: Optional[str] = None
+    """The ID that represents the private key for this Service Account"""
+
+    def as_dict(self) -> dict:
+        """Serializes the DatabricksGcpServiceAccount into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.credential_id is not None: body['credential_id'] = self.credential_id
+        if self.email is not None: body['email'] = self.email
+        if self.private_key_id is not None: body['private_key_id'] = self.private_key_id
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DatabricksGcpServiceAccount into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.credential_id is not None: body['credential_id'] = self.credential_id
+        if self.email is not None: body['email'] = self.email
+        if self.private_key_id is not None: body['private_key_id'] = self.private_key_id
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> DatabricksGcpServiceAccount:
+        """Deserializes the DatabricksGcpServiceAccount from a dictionary."""
+        return cls(credential_id=d.get('credential_id', None),
+                   email=d.get('email', None),
+                   private_key_id=d.get('private_key_id', None))
+
+
 @dataclass
 class DatabricksGcpServiceAccountRequest:
 
@@ -1959,6 +2522,11 @@ class DatabricksGcpServiceAccountRequest:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DatabricksGcpServiceAccountRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DatabricksGcpServiceAccountRequest:
         """Deserializes the DatabricksGcpServiceAccountRequest from a dictionary."""
@@ -1980,6 +2548,13 @@ class DatabricksGcpServiceAccountResponse:
         if self.email is not None: body['email'] = self.email
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DatabricksGcpServiceAccountResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.credential_id is not None: body['credential_id'] = self.credential_id
+        if self.email is not None: body['email'] = self.email
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DatabricksGcpServiceAccountResponse:
         """Deserializes the DatabricksGcpServiceAccountResponse from a dictionary."""
@@ -1994,6 +2569,11 @@ class DeleteAliasResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeleteAliasResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DeleteAliasResponse:
         """Deserializes the DeleteAliasResponse from a dictionary."""
@@ -2008,6 +2588,11 @@ class DeleteCredentialResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeleteCredentialResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DeleteCredentialResponse:
         """Deserializes the DeleteCredentialResponse from a dictionary."""
@@ -2022,6 +2607,11 @@ class DeleteResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeleteResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DeleteResponse:
         """Deserializes the DeleteResponse from a dictionary."""
@@ -2042,6 +2632,12 @@ class DeltaRuntimePropertiesKvPairs:
         if self.delta_runtime_properties: body['delta_runtime_properties'] = self.delta_runtime_properties
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DeltaRuntimePropertiesKvPairs into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.delta_runtime_properties: body['delta_runtime_properties'] = self.delta_runtime_properties
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DeltaRuntimePropertiesKvPairs:
         """Deserializes the DeltaRuntimePropertiesKvPairs from a dictionary."""
@@ -2066,6 +2662,13 @@ class Dependency:
         if self.table: body['table'] = self.table.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the Dependency into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.function: body['function'] = self.function
+        if self.table: body['table'] = self.table
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> Dependency:
         """Deserializes the Dependency from a dictionary."""
@@ -2086,6 +2689,12 @@ class DependencyList:
         if self.dependencies: body['dependencies'] = [v.as_dict() for v in self.dependencies]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DependencyList into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.dependencies: body['dependencies'] = self.dependencies
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DependencyList:
         """Deserializes the DependencyList from a dictionary."""
@@ -2100,6 +2709,11 @@ class DisableResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the DisableResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> DisableResponse:
         """Deserializes the DisableResponse from a dictionary."""
@@ -2118,6 +2732,12 @@ class EffectivePermissionsList:
             body['privilege_assignments'] = [v.as_dict() for v in self.privilege_assignments]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EffectivePermissionsList into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.privilege_assignments: body['privilege_assignments'] = self.privilege_assignments
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EffectivePermissionsList:
         """Deserializes the EffectivePermissionsList from a dictionary."""
@@ -2146,6 +2766,14 @@ class EffectivePredictiveOptimizationFlag:
         if self.value is not None: body['value'] = self.value.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EffectivePredictiveOptimizationFlag into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.inherited_from_name is not None: body['inherited_from_name'] = self.inherited_from_name
+        if self.inherited_from_type is not None: body['inherited_from_type'] = self.inherited_from_type
+        if self.value is not None: body['value'] = self.value
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EffectivePredictiveOptimizationFlag:
         """Deserializes the EffectivePredictiveOptimizationFlag from a dictionary."""
@@ -2184,6 +2812,14 @@ class EffectivePrivilege:
         if self.privilege is not None: body['privilege'] = self.privilege.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EffectivePrivilege into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.inherited_from_name is not None: body['inherited_from_name'] = self.inherited_from_name
+        if self.inherited_from_type is not None: body['inherited_from_type'] = self.inherited_from_type
+        if self.privilege is not None: body['privilege'] = self.privilege
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EffectivePrivilege:
         """Deserializes the EffectivePrivilege from a dictionary."""
@@ -2207,6 +2843,13 @@ class EffectivePrivilegeAssignment:
         if self.privileges: body['privileges'] = [v.as_dict() for v in self.privileges]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EffectivePrivilegeAssignment into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.principal is not None: body['principal'] = self.principal
+        if self.privileges: body['privileges'] = self.privileges
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EffectivePrivilegeAssignment:
         """Deserializes the EffectivePrivilegeAssignment from a dictionary."""
@@ -2230,6 +2873,11 @@ class EnableResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EnableResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EnableResponse:
         """Deserializes the EnableResponse from a dictionary."""
@@ -2249,6 +2897,12 @@ class EncryptionDetails:
         if self.sse_encryption_details: body['sse_encryption_details'] = self.sse_encryption_details.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the EncryptionDetails into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.sse_encryption_details: body['sse_encryption_details'] = self.sse_encryption_details
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> EncryptionDetails:
         """Deserializes the EncryptionDetails from a dictionary."""
@@ -2332,6 +2986,28 @@ class ExternalLocationInfo:
         if self.url is not None: body['url'] = self.url
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ExternalLocationInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.access_point is not None: body['access_point'] = self.access_point
+        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: body['created_by'] = self.created_by
+        if self.credential_id is not None: body['credential_id'] = self.credential_id
+        if self.credential_name is not None: body['credential_name'] = self.credential_name
+        if self.encryption_details: body['encryption_details'] = self.encryption_details
+        if self.fallback is not None: body['fallback'] = self.fallback
+        if self.isolation_mode is not None: body['isolation_mode'] = self.isolation_mode
+        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.read_only is not None: body['read_only'] = self.read_only
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.updated_by is not None: body['updated_by'] = self.updated_by
+        if self.url is not None: body['url'] = self.url
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ExternalLocationInfo:
         """Deserializes the ExternalLocationInfo from a dictionary."""
@@ -2376,6 +3052,14 @@ class FailedStatus:
         if self.timestamp is not None: body['timestamp'] = self.timestamp
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the FailedStatus into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.last_processed_commit_version is not None:
+            body['last_processed_commit_version'] = self.last_processed_commit_version
+        if self.timestamp is not None: body['timestamp'] = self.timestamp
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> FailedStatus:
         """Deserializes the FailedStatus from a dictionary."""
@@ -2406,6 +3090,15 @@ class ForeignKeyConstraint:
         if self.parent_table is not None: body['parent_table'] = self.parent_table
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ForeignKeyConstraint into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.child_columns: body['child_columns'] = self.child_columns
+        if self.name is not None: body['name'] = self.name
+        if self.parent_columns: body['parent_columns'] = self.parent_columns
+        if self.parent_table is not None: body['parent_table'] = self.parent_table
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ForeignKeyConstraint:
         """Deserializes the ForeignKeyConstraint from a dictionary."""
@@ -2429,6 +3122,12 @@ class FunctionDependency:
         if self.function_full_name is not None: body['function_full_name'] = self.function_full_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the FunctionDependency into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.function_full_name is not None: body['function_full_name'] = self.function_full_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> FunctionDependency:
         """Deserializes the FunctionDependency from a dictionary."""
@@ -2565,6 +3264,41 @@ class FunctionInfo:
         if self.updated_by is not None: body['updated_by'] = self.updated_by
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the FunctionInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.browse_only is not None: body['browse_only'] = self.browse_only
+        if self.catalog_name is not None: body['catalog_name'] = self.catalog_name
+        if self.comment is not None: body['comment'] = self.comment
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.created_by is not None: body['created_by'] = self.created_by
+        if self.data_type is not None: body['data_type'] = self.data_type
+        if self.external_language is not None: body['external_language'] = self.external_language
+        if self.external_name is not None: body['external_name'] = self.external_name
+        if self.full_data_type is not None: body['full_data_type'] = self.full_data_type
+        if self.full_name is not None: body['full_name'] = self.full_name
+        if self.function_id is not None: body['function_id'] = self.function_id
+        if self.input_params: body['input_params'] = self.input_params
+        if self.is_deterministic is not None: body['is_deterministic'] = self.is_deterministic
+        if self.is_null_call is not None: body['is_null_call'] = self.is_null_call
+        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.parameter_style is not None: body['parameter_style'] = self.parameter_style
+        if self.properties is not None: body['properties'] = self.properties
+        if self.return_params: body['return_params'] = self.return_params
+        if self.routine_body is not None: body['routine_body'] = self.routine_body
+        if self.routine_definition is not None: body['routine_definition'] = self.routine_definition
+        if self.routine_dependencies: body['routine_dependencies'] = self.routine_dependencies
+        if self.schema_name is not None: body['schema_name'] = self.schema_name
+        if self.security_type is not None: body['security_type'] = self.security_type
+        if self.specific_name is not None: body['specific_name'] = self.specific_name
+        if self.sql_data_access is not None: body['sql_data_access'] = self.sql_data_access
+        if self.sql_path is not None: body['sql_path'] = self.sql_path
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.updated_by is not None: body['updated_by'] = self.updated_by
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> FunctionInfo:
         """Deserializes the FunctionInfo from a dictionary."""
@@ -2639,7 +3373,6 @@ class FunctionParameterInfo:
     """Full data type spec, SQL/catalogString text."""
 
     type_name: ColumnTypeName
-    """Name of type (INT, STRUCT, MAP, etc.)."""
 
     position: int
     """Ordinal position of column (starting at position 0)."""
@@ -2685,6 +3418,23 @@ class FunctionParameterInfo:
         if self.type_text is not None: body['type_text'] = self.type_text
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the FunctionParameterInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.comment is not None: body['comment'] = self.comment
+        if self.name is not None: body['name'] = self.name
+        if self.parameter_default is not None: body['parameter_default'] = self.parameter_default
+        if self.parameter_mode is not None: body['parameter_mode'] = self.parameter_mode
+        if self.parameter_type is not None: body['parameter_type'] = self.parameter_type
+        if self.position is not None: body['position'] = self.position
+        if self.type_interval_type is not None: body['type_interval_type'] = self.type_interval_type
+        if self.type_json is not None: body['type_json'] = self.type_json
+        if self.type_name is not None: body['type_name'] = self.type_name
+        if self.type_precision is not None: body['type_precision'] = self.type_precision
+        if self.type_scale is not None: body['type_scale'] = self.type_scale
+        if self.type_text is not None: body['type_text'] = self.type_text
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> FunctionParameterInfo:
         """Deserializes the FunctionParameterInfo from a dictionary."""
@@ -2713,6 +3463,12 @@ class FunctionParameterInfos:
         if self.parameters: body['parameters'] = [v.as_dict() for v in self.parameters]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the FunctionParameterInfos into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.parameters: body['parameters'] = self.parameters
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> FunctionParameterInfos:
         """Deserializes the FunctionParameterInfos from a dictionary."""
@@ -2745,6 +3501,12 @@ class GcpOauthToken:
         if self.oauth_token is not None: body['oauth_token'] = self.oauth_token
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GcpOauthToken into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.oauth_token is not None: body['oauth_token'] = self.oauth_token
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GcpOauthToken:
         """Deserializes the GcpOauthToken from a dictionary."""
@@ -2753,7 +3515,7 @@ class GcpOauthToken:
 
 @dataclass
 class GenerateTemporaryServiceCredentialAzureOptions:
-    """Options to customize the requested temporary credential"""
+    """The Azure cloud options to customize the requested temporary credential"""
 
     resources: Optional[List[str]] = None
     """The resources to which the temporary Azure credential should apply. These resources are the
@@ -2766,25 +3528,70 @@ class GenerateTemporaryServiceCredentialAzureOptions:
         if self.resources: body['resources'] = [v for v in self.resources]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GenerateTemporaryServiceCredentialAzureOptions into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.resources: body['resources'] = self.resources
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GenerateTemporaryServiceCredentialAzureOptions:
         """Deserializes the GenerateTemporaryServiceCredentialAzureOptions from a dictionary."""
         return cls(resources=d.get('resources', None))
 
 
+@dataclass
+class GenerateTemporaryServiceCredentialGcpOptions:
+    """The GCP cloud options to customize the requested temporary credential"""
+
+    scopes: Optional[List[str]] = None
+    """The scopes to which the temporary GCP credential should apply. These resources are the scopes
+    that are passed to the token provider (see
+    https://google-auth.readthedocs.io/en/latest/reference/google.auth.html#google.auth.credentials.Credentials)"""
+
+    def as_dict(self) -> dict:
+        """Serializes the GenerateTemporaryServiceCredentialGcpOptions into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.scopes: body['scopes'] = [v for v in self.scopes]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GenerateTemporaryServiceCredentialGcpOptions into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.scopes: body['scopes'] = self.scopes
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, any]) -> GenerateTemporaryServiceCredentialGcpOptions:
+        """Deserializes the GenerateTemporaryServiceCredentialGcpOptions from a dictionary."""
+        return cls(scopes=d.get('scopes', None))
+
+
 @dataclass
 class GenerateTemporaryServiceCredentialRequest:
+    credential_name: str
+    """The name of the service credential used to generate a temporary credential"""
+
     azure_options: Optional[GenerateTemporaryServiceCredentialAzureOptions] = None
-    """Options to customize the requested temporary credential"""
+    """The Azure cloud options to customize the requested temporary credential"""
 
-    credential_name: Optional[str] = None
-    """The name of the service credential used to generate a 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."""
         body = {}
         if self.azure_options: body['azure_options'] = self.azure_options.as_dict()
         if self.credential_name is not None: body['credential_name'] = self.credential_name
+        if self.gcp_options: body['gcp_options'] = self.gcp_options.as_dict()
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GenerateTemporaryServiceCredentialRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.azure_options: body['azure_options'] = self.azure_options
+        if self.credential_name is not None: body['credential_name'] = self.credential_name
+        if self.gcp_options: body['gcp_options'] = self.gcp_options
         return body
 
     @classmethod
@@ -2792,7 +3599,8 @@ class GenerateTemporaryServiceCredentialRequest:
         """Deserializes the GenerateTemporaryServiceCredentialRequest from a dictionary."""
         return cls(azure_options=_from_dict(d, 'azure_options',
                                             GenerateTemporaryServiceCredentialAzureOptions),
-                   credential_name=d.get('credential_name', None))
+                   credential_name=d.get('credential_name', None),
+                   gcp_options=_from_dict(d, 'gcp_options', GenerateTemporaryServiceCredentialGcpOptions))
 
 
 @dataclass
@@ -2812,6 +3620,13 @@ class GenerateTemporaryTableCredentialRequest:
         if self.table_id is not None: body['table_id'] = self.table_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GenerateTemporaryTableCredentialRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.operation is not None: body['operation'] = self.operation
+        if self.table_id is not None: body['table_id'] = self.table_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GenerateTemporaryTableCredentialRequest:
         """Deserializes the GenerateTemporaryTableCredentialRequest from a dictionary."""
@@ -2861,6 +3676,18 @@ class GenerateTemporaryTableCredentialResponse:
         if self.url is not None: body['url'] = self.url
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GenerateTemporaryTableCredentialResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.aws_temp_credentials: body['aws_temp_credentials'] = self.aws_temp_credentials
+        if self.azure_aad: body['azure_aad'] = self.azure_aad
+        if self.azure_user_delegation_sas: body['azure_user_delegation_sas'] = self.azure_user_delegation_sas
+        if self.expiration_time is not None: body['expiration_time'] = self.expiration_time
+        if self.gcp_oauth_token: body['gcp_oauth_token'] = self.gcp_oauth_token
+        if self.r2_temp_credentials: body['r2_temp_credentials'] = self.r2_temp_credentials
+        if self.url is not None: body['url'] = self.url
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GenerateTemporaryTableCredentialResponse:
         """Deserializes the GenerateTemporaryTableCredentialResponse from a dictionary."""
@@ -2974,6 +3801,38 @@ class GetMetastoreSummaryResponse:
         if self.updated_by is not None: body['updated_by'] = self.updated_by
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GetMetastoreSummaryResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.cloud is not None: body['cloud'] = self.cloud
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.created_by is not None: body['created_by'] = self.created_by
+        if self.default_data_access_config_id is not None:
+            body['default_data_access_config_id'] = self.default_data_access_config_id
+        if self.delta_sharing_organization_name is not None:
+            body['delta_sharing_organization_name'] = self.delta_sharing_organization_name
+        if self.delta_sharing_recipient_token_lifetime_in_seconds is not None:
+            body[
+                'delta_sharing_recipient_token_lifetime_in_seconds'] = self.delta_sharing_recipient_token_lifetime_in_seconds
+        if self.delta_sharing_scope is not None: body['delta_sharing_scope'] = self.delta_sharing_scope
+        if self.external_access_enabled is not None:
+            body['external_access_enabled'] = self.external_access_enabled
+        if self.global_metastore_id is not None: body['global_metastore_id'] = self.global_metastore_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.privilege_model_version is not None:
+            body['privilege_model_version'] = self.privilege_model_version
+        if self.region is not None: body['region'] = self.region
+        if self.storage_root is not None: body['storage_root'] = self.storage_root
+        if self.storage_root_credential_id is not None:
+            body['storage_root_credential_id'] = self.storage_root_credential_id
+        if self.storage_root_credential_name is not None:
+            body['storage_root_credential_name'] = self.storage_root_credential_name
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.updated_by is not None: body['updated_by'] = self.updated_by
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GetMetastoreSummaryResponse:
         """Deserializes the GetMetastoreSummaryResponse from a dictionary."""
@@ -3018,6 +3877,12 @@ class GetQuotaResponse:
         if self.quota_info: body['quota_info'] = self.quota_info.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GetQuotaResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.quota_info: body['quota_info'] = self.quota_info
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> GetQuotaResponse:
         """Deserializes the GetQuotaResponse from a dictionary."""
@@ -3042,6 +3907,12 @@ class ListAccountMetastoreAssignmentsResponse:
         if self.workspace_ids: body['workspace_ids'] = [v for v in self.workspace_ids]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListAccountMetastoreAssignmentsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.workspace_ids: body['workspace_ids'] = self.workspace_ids
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListAccountMetastoreAssignmentsResponse:
         """Deserializes the ListAccountMetastoreAssignmentsResponse from a dictionary."""
@@ -3060,6 +3931,12 @@ class ListAccountStorageCredentialsResponse:
             body['storage_credentials'] = [v.as_dict() for v in self.storage_credentials]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListAccountStorageCredentialsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.storage_credentials: body['storage_credentials'] = self.storage_credentials
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListAccountStorageCredentialsResponse:
         """Deserializes the ListAccountStorageCredentialsResponse from a dictionary."""
@@ -3082,6 +3959,13 @@ class ListCatalogsResponse:
         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 ListCatalogsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.catalogs: body['catalogs'] = self.catalogs
+        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListCatalogsResponse:
         """Deserializes the ListCatalogsResponse from a dictionary."""
@@ -3105,6 +3989,13 @@ class ListConnectionsResponse:
         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 ListConnectionsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.connections: body['connections'] = self.connections
+        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]) -> ListConnectionsResponse:
         """Deserializes the ListConnectionsResponse from a dictionary."""
@@ -3127,6 +4018,13 @@ class ListCredentialsResponse:
         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 ListCredentialsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.credentials: body['credentials'] = self.credentials
+        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]) -> ListCredentialsResponse:
         """Deserializes the ListCredentialsResponse from a dictionary."""
@@ -3151,6 +4049,13 @@ class ListExternalLocationsResponse:
         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 ListExternalLocationsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.external_locations: body['external_locations'] = self.external_locations
+        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]) -> ListExternalLocationsResponse:
         """Deserializes the ListExternalLocationsResponse from a dictionary."""
@@ -3174,6 +4079,13 @@ class ListFunctionsResponse:
         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 ListFunctionsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.functions: body['functions'] = self.functions
+        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]) -> ListFunctionsResponse:
         """Deserializes the ListFunctionsResponse from a dictionary."""
@@ -3192,6 +4104,12 @@ class ListMetastoresResponse:
         if self.metastores: body['metastores'] = [v.as_dict() for v in self.metastores]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListMetastoresResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.metastores: body['metastores'] = self.metastores
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListMetastoresResponse:
         """Deserializes the ListMetastoresResponse from a dictionary."""
@@ -3213,6 +4131,13 @@ class ListModelVersionsResponse:
         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 ListModelVersionsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.model_versions: body['model_versions'] = self.model_versions
+        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]) -> ListModelVersionsResponse:
         """Deserializes the ListModelVersionsResponse from a dictionary."""
@@ -3236,6 +4161,13 @@ class ListQuotasResponse:
         if self.quotas: body['quotas'] = [v.as_dict() for v in self.quotas]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListQuotasResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.quotas: body['quotas'] = self.quotas
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListQuotasResponse:
         """Deserializes the ListQuotasResponse from a dictionary."""
@@ -3258,6 +4190,13 @@ class ListRegisteredModelsResponse:
         if self.registered_models: body['registered_models'] = [v.as_dict() for v in self.registered_models]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListRegisteredModelsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.registered_models: body['registered_models'] = self.registered_models
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListRegisteredModelsResponse:
         """Deserializes the ListRegisteredModelsResponse from a dictionary."""
@@ -3281,6 +4220,13 @@ class ListSchemasResponse:
         if self.schemas: body['schemas'] = [v.as_dict() for v in self.schemas]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListSchemasResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.schemas: body['schemas'] = self.schemas
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListSchemasResponse:
         """Deserializes the ListSchemasResponse from a dictionary."""
@@ -3304,6 +4250,13 @@ class ListStorageCredentialsResponse:
             body['storage_credentials'] = [v.as_dict() for v in self.storage_credentials]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListStorageCredentialsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.storage_credentials: body['storage_credentials'] = self.storage_credentials
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListStorageCredentialsResponse:
         """Deserializes the ListStorageCredentialsResponse from a dictionary."""
@@ -3327,6 +4280,13 @@ class ListSystemSchemasResponse:
         if self.schemas: body['schemas'] = [v.as_dict() for v in self.schemas]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListSystemSchemasResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.schemas: body['schemas'] = self.schemas
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListSystemSchemasResponse:
         """Deserializes the ListSystemSchemasResponse from a dictionary."""
@@ -3350,6 +4310,13 @@ class ListTableSummariesResponse:
         if self.tables: body['tables'] = [v.as_dict() for v in self.tables]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListTableSummariesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.tables: body['tables'] = self.tables
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListTableSummariesResponse:
         """Deserializes the ListTableSummariesResponse from a dictionary."""
@@ -3373,6 +4340,13 @@ class ListTablesResponse:
         if self.tables: body['tables'] = [v.as_dict() for v in self.tables]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListTablesResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.tables: body['tables'] = self.tables
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListTablesResponse:
         """Deserializes the ListTablesResponse from a dictionary."""
@@ -3396,6 +4370,13 @@ class ListVolumesResponseContent:
         if self.volumes: body['volumes'] = [v.as_dict() for v in self.volumes]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ListVolumesResponseContent into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.next_page_token is not None: body['next_page_token'] = self.next_page_token
+        if self.volumes: body['volumes'] = self.volumes
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ListVolumesResponseContent:
         """Deserializes the ListVolumesResponseContent from a dictionary."""
@@ -3428,6 +4409,14 @@ class MetastoreAssignment:
         if self.workspace_id is not None: body['workspace_id'] = self.workspace_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the MetastoreAssignment into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.default_catalog_name is not None: body['default_catalog_name'] = self.default_catalog_name
+        if self.metastore_id is not None: body['metastore_id'] = self.metastore_id
+        if self.workspace_id is not None: body['workspace_id'] = self.workspace_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> MetastoreAssignment:
         """Deserializes the MetastoreAssignment from a dictionary."""
@@ -3528,6 +4517,38 @@ class MetastoreInfo:
         if self.updated_by is not None: body['updated_by'] = self.updated_by
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the MetastoreInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.cloud is not None: body['cloud'] = self.cloud
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.created_by is not None: body['created_by'] = self.created_by
+        if self.default_data_access_config_id is not None:
+            body['default_data_access_config_id'] = self.default_data_access_config_id
+        if self.delta_sharing_organization_name is not None:
+            body['delta_sharing_organization_name'] = self.delta_sharing_organization_name
+        if self.delta_sharing_recipient_token_lifetime_in_seconds is not None:
+            body[
+                'delta_sharing_recipient_token_lifetime_in_seconds'] = self.delta_sharing_recipient_token_lifetime_in_seconds
+        if self.delta_sharing_scope is not None: body['delta_sharing_scope'] = self.delta_sharing_scope
+        if self.external_access_enabled is not None:
+            body['external_access_enabled'] = self.external_access_enabled
+        if self.global_metastore_id is not None: body['global_metastore_id'] = self.global_metastore_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.privilege_model_version is not None:
+            body['privilege_model_version'] = self.privilege_model_version
+        if self.region is not None: body['region'] = self.region
+        if self.storage_root is not None: body['storage_root'] = self.storage_root
+        if self.storage_root_credential_id is not None:
+            body['storage_root_credential_id'] = self.storage_root_credential_id
+        if self.storage_root_credential_name is not None:
+            body['storage_root_credential_name'] = self.storage_root_credential_name
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.updated_by is not None: body['updated_by'] = self.updated_by
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> MetastoreInfo:
         """Deserializes the MetastoreInfo from a dictionary."""
@@ -3647,6 +4668,31 @@ class ModelVersionInfo:
         if self.version is not None: body['version'] = self.version
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ModelVersionInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.aliases: body['aliases'] = self.aliases
+        if self.browse_only is not None: body['browse_only'] = self.browse_only
+        if self.catalog_name is not None: body['catalog_name'] = self.catalog_name
+        if self.comment is not None: body['comment'] = self.comment
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.created_by is not None: body['created_by'] = self.created_by
+        if self.id is not None: body['id'] = self.id
+        if self.metastore_id is not None: body['metastore_id'] = self.metastore_id
+        if self.model_name is not None: body['model_name'] = self.model_name
+        if self.model_version_dependencies:
+            body['model_version_dependencies'] = self.model_version_dependencies
+        if self.run_id is not None: body['run_id'] = self.run_id
+        if self.run_workspace_id is not None: body['run_workspace_id'] = self.run_workspace_id
+        if self.schema_name is not None: body['schema_name'] = self.schema_name
+        if self.source is not None: body['source'] = self.source
+        if self.status is not None: body['status'] = self.status
+        if self.storage_location is not None: body['storage_location'] = self.storage_location
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.updated_by is not None: body['updated_by'] = self.updated_by
+        if self.version is not None: body['version'] = self.version
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ModelVersionInfo:
         """Deserializes the ModelVersionInfo from a dictionary."""
@@ -3703,6 +4749,15 @@ class MonitorCronSchedule:
         if self.timezone_id is not None: body['timezone_id'] = self.timezone_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the MonitorCronSchedule into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.pause_status is not None: body['pause_status'] = self.pause_status
+        if self.quartz_cron_expression is not None:
+            body['quartz_cron_expression'] = self.quartz_cron_expression
+        if self.timezone_id is not None: body['timezone_id'] = self.timezone_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> MonitorCronSchedule:
         """Deserializes the MonitorCronSchedule from a dictionary."""
@@ -3729,6 +4784,12 @@ class MonitorDataClassificationConfig:
         if self.enabled is not None: body['enabled'] = self.enabled
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the MonitorDataClassificationConfig into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.enabled is not None: body['enabled'] = self.enabled
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> MonitorDataClassificationConfig:
         """Deserializes the MonitorDataClassificationConfig from a dictionary."""
@@ -3747,6 +4808,12 @@ class MonitorDestination:
         if self.email_addresses: body['email_addresses'] = [v for v in self.email_addresses]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the MonitorDestination into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.email_addresses: body['email_addresses'] = self.email_addresses
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> MonitorDestination:
         """Deserializes the MonitorDestination from a dictionary."""
@@ -3798,6 +4865,18 @@ class MonitorInferenceLog:
         if self.timestamp_col is not None: body['timestamp_col'] = self.timestamp_col
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the MonitorInferenceLog into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.granularities: body['granularities'] = self.granularities
+        if self.label_col is not None: body['label_col'] = self.label_col
+        if self.model_id_col is not None: body['model_id_col'] = self.model_id_col
+        if self.prediction_col is not None: body['prediction_col'] = self.prediction_col
+        if self.prediction_proba_col is not None: body['prediction_proba_col'] = self.prediction_proba_col
+        if self.problem_type is not None: body['problem_type'] = self.problem_type
+        if self.timestamp_col is not None: body['timestamp_col'] = self.timestamp_col
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> MonitorInferenceLog:
         """Deserializes the MonitorInferenceLog from a dictionary."""
@@ -3887,26 +4966,53 @@ class MonitorInfo:
         body = {}
         if self.assets_dir is not None: body['assets_dir'] = self.assets_dir
         if self.baseline_table_name is not None: body['baseline_table_name'] = self.baseline_table_name
-        if self.custom_metrics: body['custom_metrics'] = [v.as_dict() for v in self.custom_metrics]
+        if self.custom_metrics: body['custom_metrics'] = [v.as_dict() for v in self.custom_metrics]
+        if self.dashboard_id is not None: body['dashboard_id'] = self.dashboard_id
+        if self.data_classification_config:
+            body['data_classification_config'] = self.data_classification_config.as_dict()
+        if self.drift_metrics_table_name is not None:
+            body['drift_metrics_table_name'] = self.drift_metrics_table_name
+        if self.inference_log: body['inference_log'] = self.inference_log.as_dict()
+        if self.latest_monitor_failure_msg is not None:
+            body['latest_monitor_failure_msg'] = self.latest_monitor_failure_msg
+        if self.monitor_version is not None: body['monitor_version'] = self.monitor_version
+        if self.notifications: body['notifications'] = self.notifications.as_dict()
+        if self.output_schema_name is not None: body['output_schema_name'] = self.output_schema_name
+        if self.profile_metrics_table_name is not None:
+            body['profile_metrics_table_name'] = self.profile_metrics_table_name
+        if self.schedule: body['schedule'] = self.schedule.as_dict()
+        if self.slicing_exprs: body['slicing_exprs'] = [v for v in self.slicing_exprs]
+        if self.snapshot: body['snapshot'] = self.snapshot.as_dict()
+        if self.status is not None: body['status'] = self.status.value
+        if self.table_name is not None: body['table_name'] = self.table_name
+        if self.time_series: body['time_series'] = self.time_series.as_dict()
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the MonitorInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.assets_dir is not None: body['assets_dir'] = self.assets_dir
+        if self.baseline_table_name is not None: body['baseline_table_name'] = self.baseline_table_name
+        if self.custom_metrics: body['custom_metrics'] = self.custom_metrics
         if self.dashboard_id is not None: body['dashboard_id'] = self.dashboard_id
         if self.data_classification_config:
-            body['data_classification_config'] = self.data_classification_config.as_dict()
+            body['data_classification_config'] = self.data_classification_config
         if self.drift_metrics_table_name is not None:
             body['drift_metrics_table_name'] = self.drift_metrics_table_name
-        if self.inference_log: body['inference_log'] = self.inference_log.as_dict()
+        if self.inference_log: body['inference_log'] = self.inference_log
         if self.latest_monitor_failure_msg is not None:
             body['latest_monitor_failure_msg'] = self.latest_monitor_failure_msg
         if self.monitor_version is not None: body['monitor_version'] = self.monitor_version
-        if self.notifications: body['notifications'] = self.notifications.as_dict()
+        if self.notifications: body['notifications'] = self.notifications
         if self.output_schema_name is not None: body['output_schema_name'] = self.output_schema_name
         if self.profile_metrics_table_name is not None:
             body['profile_metrics_table_name'] = self.profile_metrics_table_name
-        if self.schedule: body['schedule'] = self.schedule.as_dict()
-        if self.slicing_exprs: body['slicing_exprs'] = [v for v in self.slicing_exprs]
-        if self.snapshot: body['snapshot'] = self.snapshot.as_dict()
-        if self.status is not None: body['status'] = self.status.value
+        if self.schedule: body['schedule'] = self.schedule
+        if self.slicing_exprs: body['slicing_exprs'] = self.slicing_exprs
+        if self.snapshot: body['snapshot'] = self.snapshot
+        if self.status is not None: body['status'] = self.status
         if self.table_name is not None: body['table_name'] = self.table_name
-        if self.time_series: body['time_series'] = self.time_series.as_dict()
+        if self.time_series: body['time_series'] = self.time_series
         return body
 
     @classmethod
@@ -3980,6 +5086,16 @@ class MonitorMetric:
         if self.type is not None: body['type'] = self.type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the MonitorMetric into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.definition is not None: body['definition'] = self.definition
+        if self.input_columns: body['input_columns'] = self.input_columns
+        if self.name is not None: body['name'] = self.name
+        if self.output_data_type is not None: body['output_data_type'] = self.output_data_type
+        if self.type is not None: body['type'] = self.type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> MonitorMetric:
         """Deserializes the MonitorMetric from a dictionary."""
@@ -4020,6 +5136,14 @@ class MonitorNotifications:
             body['on_new_classification_tag_detected'] = self.on_new_classification_tag_detected.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the MonitorNotifications into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.on_failure: body['on_failure'] = self.on_failure
+        if self.on_new_classification_tag_detected:
+            body['on_new_classification_tag_detected'] = self.on_new_classification_tag_detected
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> MonitorNotifications:
         """Deserializes the MonitorNotifications from a dictionary."""
@@ -4059,6 +5183,17 @@ class MonitorRefreshInfo:
         if self.trigger is not None: body['trigger'] = self.trigger.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the MonitorRefreshInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.end_time_ms is not None: body['end_time_ms'] = self.end_time_ms
+        if self.message is not None: body['message'] = self.message
+        if self.refresh_id is not None: body['refresh_id'] = self.refresh_id
+        if self.start_time_ms is not None: body['start_time_ms'] = self.start_time_ms
+        if self.state is not None: body['state'] = self.state
+        if self.trigger is not None: body['trigger'] = self.trigger
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> MonitorRefreshInfo:
         """Deserializes the MonitorRefreshInfo from a dictionary."""
@@ -4098,6 +5233,12 @@ class MonitorRefreshListResponse:
         if self.refreshes: body['refreshes'] = [v.as_dict() for v in self.refreshes]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the MonitorRefreshListResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.refreshes: body['refreshes'] = self.refreshes
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> MonitorRefreshListResponse:
         """Deserializes the MonitorRefreshListResponse from a dictionary."""
@@ -4112,6 +5253,11 @@ class MonitorSnapshot:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the MonitorSnapshot into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> MonitorSnapshot:
         """Deserializes the MonitorSnapshot from a dictionary."""
@@ -4139,6 +5285,13 @@ class MonitorTimeSeries:
         if self.timestamp_col is not None: body['timestamp_col'] = self.timestamp_col
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the MonitorTimeSeries into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.granularities: body['granularities'] = self.granularities
+        if self.timestamp_col is not None: body['timestamp_col'] = self.timestamp_col
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> MonitorTimeSeries:
         """Deserializes the MonitorTimeSeries from a dictionary."""
@@ -4156,6 +5309,12 @@ class NamedTableConstraint:
         if self.name is not None: body['name'] = self.name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the NamedTableConstraint 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]) -> NamedTableConstraint:
         """Deserializes the NamedTableConstraint from a dictionary."""
@@ -4194,6 +5353,17 @@ class OnlineTable:
             body['unity_catalog_provisioning_state'] = self.unity_catalog_provisioning_state.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the OnlineTable into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.name is not None: body['name'] = self.name
+        if self.spec: body['spec'] = self.spec
+        if self.status: body['status'] = self.status
+        if self.table_serving_url is not None: body['table_serving_url'] = self.table_serving_url
+        if self.unity_catalog_provisioning_state is not None:
+            body['unity_catalog_provisioning_state'] = self.unity_catalog_provisioning_state
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> OnlineTable:
         """Deserializes the OnlineTable from a dictionary."""
@@ -4249,6 +5419,19 @@ class OnlineTableSpec:
         if self.timeseries_key is not None: body['timeseries_key'] = self.timeseries_key
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the OnlineTableSpec into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.perform_full_copy is not None: body['perform_full_copy'] = self.perform_full_copy
+        if self.pipeline_id is not None: body['pipeline_id'] = self.pipeline_id
+        if self.primary_key_columns: body['primary_key_columns'] = self.primary_key_columns
+        if self.run_continuously: body['run_continuously'] = self.run_continuously
+        if self.run_triggered: body['run_triggered'] = self.run_triggered
+        if self.source_table_full_name is not None:
+            body['source_table_full_name'] = self.source_table_full_name
+        if self.timeseries_key is not None: body['timeseries_key'] = self.timeseries_key
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> OnlineTableSpec:
         """Deserializes the OnlineTableSpec from a dictionary."""
@@ -4270,6 +5453,11 @@ class OnlineTableSpecContinuousSchedulingPolicy:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the OnlineTableSpecContinuousSchedulingPolicy into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> OnlineTableSpecContinuousSchedulingPolicy:
         """Deserializes the OnlineTableSpecContinuousSchedulingPolicy from a dictionary."""
@@ -4284,6 +5472,11 @@ class OnlineTableSpecTriggeredSchedulingPolicy:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the OnlineTableSpecTriggeredSchedulingPolicy into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> OnlineTableSpecTriggeredSchedulingPolicy:
         """Deserializes the OnlineTableSpecTriggeredSchedulingPolicy from a dictionary."""
@@ -4345,6 +5538,17 @@ class OnlineTableStatus:
             body['triggered_update_status'] = self.triggered_update_status.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the OnlineTableStatus into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.continuous_update_status: body['continuous_update_status'] = self.continuous_update_status
+        if self.detailed_state is not None: body['detailed_state'] = self.detailed_state
+        if self.failed_status: body['failed_status'] = self.failed_status
+        if self.message is not None: body['message'] = self.message
+        if self.provisioning_status: body['provisioning_status'] = self.provisioning_status
+        if self.triggered_update_status: body['triggered_update_status'] = self.triggered_update_status
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> OnlineTableStatus:
         """Deserializes the OnlineTableStatus from a dictionary."""
@@ -4375,6 +5579,14 @@ class PermissionsChange:
         if self.remove: body['remove'] = [v.value for v in self.remove]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PermissionsChange into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.add: body['add'] = self.add
+        if self.principal is not None: body['principal'] = self.principal
+        if self.remove: body['remove'] = self.remove
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> PermissionsChange:
         """Deserializes the PermissionsChange from a dictionary."""
@@ -4395,6 +5607,12 @@ class PermissionsList:
             body['privilege_assignments'] = [v.as_dict() for v in self.privilege_assignments]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PermissionsList into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.privilege_assignments: body['privilege_assignments'] = self.privilege_assignments
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> PermissionsList:
         """Deserializes the PermissionsList from a dictionary."""
@@ -4434,6 +5652,19 @@ class PipelineProgress:
         if self.total_row_count is not None: body['total_row_count'] = self.total_row_count
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PipelineProgress into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.estimated_completion_time_seconds is not None:
+            body['estimated_completion_time_seconds'] = self.estimated_completion_time_seconds
+        if self.latest_version_currently_processing is not None:
+            body['latest_version_currently_processing'] = self.latest_version_currently_processing
+        if self.sync_progress_completion is not None:
+            body['sync_progress_completion'] = self.sync_progress_completion
+        if self.synced_row_count is not None: body['synced_row_count'] = self.synced_row_count
+        if self.total_row_count is not None: body['total_row_count'] = self.total_row_count
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> PipelineProgress:
         """Deserializes the PipelineProgress from a dictionary."""
@@ -4459,6 +5690,13 @@ class PrimaryKeyConstraint:
         if self.name is not None: body['name'] = self.name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PrimaryKeyConstraint into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.child_columns: body['child_columns'] = self.child_columns
+        if self.name is not None: body['name'] = self.name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> PrimaryKeyConstraint:
         """Deserializes the PrimaryKeyConstraint from a dictionary."""
@@ -4477,6 +5715,7 @@ class Privilege(Enum):
     CREATE_EXTERNAL_TABLE = 'CREATE_EXTERNAL_TABLE'
     CREATE_EXTERNAL_VOLUME = 'CREATE_EXTERNAL_VOLUME'
     CREATE_FOREIGN_CATALOG = 'CREATE_FOREIGN_CATALOG'
+    CREATE_FOREIGN_SECURABLE = 'CREATE_FOREIGN_SECURABLE'
     CREATE_FUNCTION = 'CREATE_FUNCTION'
     CREATE_MANAGED_STORAGE = 'CREATE_MANAGED_STORAGE'
     CREATE_MATERIALIZED_VIEW = 'CREATE_MATERIALIZED_VIEW'
@@ -4528,6 +5767,13 @@ class PrivilegeAssignment:
         if self.privileges: body['privileges'] = [v.value for v in self.privileges]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the PrivilegeAssignment into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.principal is not None: body['principal'] = self.principal
+        if self.privileges: body['privileges'] = self.privileges
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> PrivilegeAssignment:
         """Deserializes the PrivilegeAssignment from a dictionary."""
@@ -4549,6 +5795,12 @@ class ProvisioningInfo:
         if self.state is not None: body['state'] = self.state.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ProvisioningInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.state is not None: body['state'] = self.state
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ProvisioningInfo:
         """Deserializes the ProvisioningInfo from a dictionary."""
@@ -4580,6 +5832,13 @@ class ProvisioningStatus:
             body['initial_pipeline_sync_progress'] = self.initial_pipeline_sync_progress.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ProvisioningStatus into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.initial_pipeline_sync_progress:
+            body['initial_pipeline_sync_progress'] = self.initial_pipeline_sync_progress
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ProvisioningStatus:
         """Deserializes the ProvisioningStatus from a dictionary."""
@@ -4619,6 +5878,17 @@ class QuotaInfo:
         if self.quota_name is not None: body['quota_name'] = self.quota_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the QuotaInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.last_refreshed_at is not None: body['last_refreshed_at'] = self.last_refreshed_at
+        if self.parent_full_name is not None: body['parent_full_name'] = self.parent_full_name
+        if self.parent_securable_type is not None: body['parent_securable_type'] = self.parent_securable_type
+        if self.quota_count is not None: body['quota_count'] = self.quota_count
+        if self.quota_limit is not None: body['quota_limit'] = self.quota_limit
+        if self.quota_name is not None: body['quota_name'] = self.quota_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> QuotaInfo:
         """Deserializes the QuotaInfo from a dictionary."""
@@ -4652,6 +5922,14 @@ class R2Credentials:
         if self.session_token is not None: body['session_token'] = self.session_token
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the R2Credentials into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.access_key_id is not None: body['access_key_id'] = self.access_key_id
+        if self.secret_access_key is not None: body['secret_access_key'] = self.secret_access_key
+        if self.session_token is not None: body['session_token'] = self.session_token
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> R2Credentials:
         """Deserializes the R2Credentials from a dictionary."""
@@ -4676,6 +5954,13 @@ class RegenerateDashboardRequest:
         if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the RegenerateDashboardRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.table_name is not None: body['table_name'] = self.table_name
+        if self.warehouse_id is not None: body['warehouse_id'] = self.warehouse_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> RegenerateDashboardRequest:
         """Deserializes the RegenerateDashboardRequest from a dictionary."""
@@ -4697,6 +5982,13 @@ class RegenerateDashboardResponse:
         if self.parent_folder is not None: body['parent_folder'] = self.parent_folder
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the RegenerateDashboardResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.dashboard_id is not None: body['dashboard_id'] = self.dashboard_id
+        if self.parent_folder is not None: body['parent_folder'] = self.parent_folder
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> RegenerateDashboardResponse:
         """Deserializes the RegenerateDashboardResponse from a dictionary."""
@@ -4720,6 +6012,13 @@ class RegisteredModelAlias:
         if self.version_num is not None: body['version_num'] = self.version_num
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the RegisteredModelAlias into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.alias_name is not None: body['alias_name'] = self.alias_name
+        if self.version_num is not None: body['version_num'] = self.version_num
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> RegisteredModelAlias:
         """Deserializes the RegisteredModelAlias from a dictionary."""
@@ -4790,6 +6089,25 @@ class RegisteredModelInfo:
         if self.updated_by is not None: body['updated_by'] = self.updated_by
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the RegisteredModelInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.aliases: body['aliases'] = self.aliases
+        if self.browse_only is not None: body['browse_only'] = self.browse_only
+        if self.catalog_name is not None: body['catalog_name'] = self.catalog_name
+        if self.comment is not None: body['comment'] = self.comment
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.created_by is not None: body['created_by'] = self.created_by
+        if self.full_name is not None: body['full_name'] = self.full_name
+        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.schema_name is not None: body['schema_name'] = self.schema_name
+        if self.storage_location is not None: body['storage_location'] = self.storage_location
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.updated_by is not None: body['updated_by'] = self.updated_by
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> RegisteredModelInfo:
         """Deserializes the RegisteredModelInfo from a dictionary."""
@@ -4892,6 +6210,31 @@ class SchemaInfo:
         if self.updated_by is not None: body['updated_by'] = self.updated_by
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the SchemaInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.browse_only is not None: body['browse_only'] = self.browse_only
+        if self.catalog_name is not None: body['catalog_name'] = self.catalog_name
+        if self.catalog_type is not None: body['catalog_type'] = self.catalog_type
+        if self.comment is not None: body['comment'] = self.comment
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.created_by is not None: body['created_by'] = self.created_by
+        if self.effective_predictive_optimization_flag:
+            body['effective_predictive_optimization_flag'] = self.effective_predictive_optimization_flag
+        if self.enable_predictive_optimization is not None:
+            body['enable_predictive_optimization'] = self.enable_predictive_optimization
+        if self.full_name is not None: body['full_name'] = self.full_name
+        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.schema_id is not None: body['schema_id'] = self.schema_id
+        if self.storage_location is not None: body['storage_location'] = self.storage_location
+        if self.storage_root is not None: body['storage_root'] = self.storage_root
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.updated_by is not None: body['updated_by'] = self.updated_by
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> SchemaInfo:
         """Deserializes the SchemaInfo from a dictionary."""
@@ -4956,6 +6299,13 @@ class SetArtifactAllowlist:
         if self.artifact_type is not None: body['artifact_type'] = self.artifact_type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the SetArtifactAllowlist into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.artifact_matchers: body['artifact_matchers'] = self.artifact_matchers
+        if self.artifact_type is not None: body['artifact_type'] = self.artifact_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> SetArtifactAllowlist:
         """Deserializes the SetArtifactAllowlist from a dictionary."""
@@ -4982,6 +6332,14 @@ class SetRegisteredModelAliasRequest:
         if self.version_num is not None: body['version_num'] = self.version_num
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the SetRegisteredModelAliasRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.alias is not None: body['alias'] = self.alias
+        if self.full_name is not None: body['full_name'] = self.full_name
+        if self.version_num is not None: body['version_num'] = self.version_num
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> SetRegisteredModelAliasRequest:
         """Deserializes the SetRegisteredModelAliasRequest from a dictionary."""
@@ -5007,6 +6365,13 @@ class SseEncryptionDetails:
         if self.aws_kms_key_arn is not None: body['aws_kms_key_arn'] = self.aws_kms_key_arn
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the SseEncryptionDetails into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.algorithm is not None: body['algorithm'] = self.algorithm
+        if self.aws_kms_key_arn is not None: body['aws_kms_key_arn'] = self.aws_kms_key_arn
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> SseEncryptionDetails:
         """Deserializes the SseEncryptionDetails from a dictionary."""
@@ -5102,6 +6467,31 @@ class StorageCredentialInfo:
             body['used_for_managed_storage'] = self.used_for_managed_storage
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the StorageCredentialInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.aws_iam_role: body['aws_iam_role'] = self.aws_iam_role
+        if self.azure_managed_identity: body['azure_managed_identity'] = self.azure_managed_identity
+        if self.azure_service_principal: body['azure_service_principal'] = self.azure_service_principal
+        if self.cloudflare_api_token: body['cloudflare_api_token'] = self.cloudflare_api_token
+        if self.comment is not None: body['comment'] = self.comment
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.created_by is not None: body['created_by'] = self.created_by
+        if self.databricks_gcp_service_account:
+            body['databricks_gcp_service_account'] = self.databricks_gcp_service_account
+        if self.full_name is not None: body['full_name'] = self.full_name
+        if self.id is not None: body['id'] = self.id
+        if self.isolation_mode is not None: body['isolation_mode'] = self.isolation_mode
+        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.read_only is not None: body['read_only'] = self.read_only
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.updated_by is not None: body['updated_by'] = self.updated_by
+        if self.used_for_managed_storage is not None:
+            body['used_for_managed_storage'] = self.used_for_managed_storage
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> StorageCredentialInfo:
         """Deserializes the StorageCredentialInfo from a dictionary."""
@@ -5143,6 +6533,13 @@ class SystemSchemaInfo:
         if self.state is not None: body['state'] = self.state.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the SystemSchemaInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.schema is not None: body['schema'] = self.schema
+        if self.state is not None: body['state'] = self.state
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> SystemSchemaInfo:
         """Deserializes the SystemSchemaInfo from a dictionary."""
@@ -5179,6 +6576,14 @@ class TableConstraint:
         if self.primary_key_constraint: body['primary_key_constraint'] = self.primary_key_constraint.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the TableConstraint into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.foreign_key_constraint: body['foreign_key_constraint'] = self.foreign_key_constraint
+        if self.named_table_constraint: body['named_table_constraint'] = self.named_table_constraint
+        if self.primary_key_constraint: body['primary_key_constraint'] = self.primary_key_constraint
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> TableConstraint:
         """Deserializes the TableConstraint from a dictionary."""
@@ -5201,6 +6606,12 @@ class TableDependency:
         if self.table_full_name is not None: body['table_full_name'] = self.table_full_name
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the TableDependency into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.table_full_name is not None: body['table_full_name'] = self.table_full_name
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> TableDependency:
         """Deserializes the TableDependency from a dictionary."""
@@ -5218,6 +6629,12 @@ class TableExistsResponse:
         if self.table_exists is not None: body['table_exists'] = self.table_exists
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the TableExistsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.table_exists is not None: body['table_exists'] = self.table_exists
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> TableExistsResponse:
         """Deserializes the TableExistsResponse from a dictionary."""
@@ -5370,6 +6787,48 @@ class TableInfo:
         if self.view_dependencies: body['view_dependencies'] = self.view_dependencies.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the TableInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.access_point is not None: body['access_point'] = self.access_point
+        if self.browse_only is not None: body['browse_only'] = self.browse_only
+        if self.catalog_name is not None: body['catalog_name'] = self.catalog_name
+        if self.columns: body['columns'] = self.columns
+        if self.comment is not None: body['comment'] = self.comment
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.created_by is not None: body['created_by'] = self.created_by
+        if self.data_access_configuration_id is not None:
+            body['data_access_configuration_id'] = self.data_access_configuration_id
+        if self.data_source_format is not None: body['data_source_format'] = self.data_source_format
+        if self.deleted_at is not None: body['deleted_at'] = self.deleted_at
+        if self.delta_runtime_properties_kvpairs:
+            body['delta_runtime_properties_kvpairs'] = self.delta_runtime_properties_kvpairs
+        if self.effective_predictive_optimization_flag:
+            body['effective_predictive_optimization_flag'] = self.effective_predictive_optimization_flag
+        if self.enable_predictive_optimization is not None:
+            body['enable_predictive_optimization'] = self.enable_predictive_optimization
+        if self.encryption_details: body['encryption_details'] = self.encryption_details
+        if self.full_name is not None: body['full_name'] = self.full_name
+        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.pipeline_id is not None: body['pipeline_id'] = self.pipeline_id
+        if self.properties: body['properties'] = self.properties
+        if self.row_filter: body['row_filter'] = self.row_filter
+        if self.schema_name is not None: body['schema_name'] = self.schema_name
+        if self.sql_path is not None: body['sql_path'] = self.sql_path
+        if self.storage_credential_name is not None:
+            body['storage_credential_name'] = self.storage_credential_name
+        if self.storage_location is not None: body['storage_location'] = self.storage_location
+        if self.table_constraints: body['table_constraints'] = self.table_constraints
+        if self.table_id is not None: body['table_id'] = self.table_id
+        if self.table_type is not None: body['table_type'] = self.table_type
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.updated_by is not None: body['updated_by'] = self.updated_by
+        if self.view_definition is not None: body['view_definition'] = self.view_definition
+        if self.view_dependencies: body['view_dependencies'] = self.view_dependencies
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> TableInfo:
         """Deserializes the TableInfo from a dictionary."""
@@ -5432,6 +6891,13 @@ class TableRowFilter:
         if self.input_column_names: body['input_column_names'] = [v for v in self.input_column_names]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the TableRowFilter into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.function_name is not None: body['function_name'] = self.function_name
+        if self.input_column_names: body['input_column_names'] = self.input_column_names
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> TableRowFilter:
         """Deserializes the TableRowFilter from a dictionary."""
@@ -5453,6 +6919,13 @@ class TableSummary:
         if self.table_type is not None: body['table_type'] = self.table_type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the TableSummary into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.full_name is not None: body['full_name'] = self.full_name
+        if self.table_type is not None: body['table_type'] = self.table_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> TableSummary:
         """Deserializes the TableSummary from a dictionary."""
@@ -5494,6 +6967,14 @@ class TemporaryCredentials:
         if self.expiration_time is not None: body['expiration_time'] = self.expiration_time
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the TemporaryCredentials into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.aws_temp_credentials: body['aws_temp_credentials'] = self.aws_temp_credentials
+        if self.azure_aad: body['azure_aad'] = self.azure_aad
+        if self.expiration_time is not None: body['expiration_time'] = self.expiration_time
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> TemporaryCredentials:
         """Deserializes the TemporaryCredentials from a dictionary."""
@@ -5528,6 +7009,15 @@ class TriggeredUpdateStatus:
             body['triggered_update_progress'] = self.triggered_update_progress.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the TriggeredUpdateStatus into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.last_processed_commit_version is not None:
+            body['last_processed_commit_version'] = self.last_processed_commit_version
+        if self.timestamp is not None: body['timestamp'] = self.timestamp
+        if self.triggered_update_progress: body['triggered_update_progress'] = self.triggered_update_progress
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> TriggeredUpdateStatus:
         """Deserializes the TriggeredUpdateStatus from a dictionary."""
@@ -5544,6 +7034,11 @@ class UnassignResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UnassignResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UnassignResponse:
         """Deserializes the UnassignResponse from a dictionary."""
@@ -5558,6 +7053,11 @@ class UpdateAssignmentResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateAssignmentResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateAssignmentResponse:
         """Deserializes the UpdateAssignmentResponse from a dictionary."""
@@ -5608,6 +7108,19 @@ class UpdateCatalog:
         if self.properties: body['properties'] = self.properties
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateCatalog into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.comment is not None: body['comment'] = self.comment
+        if self.enable_predictive_optimization is not None:
+            body['enable_predictive_optimization'] = self.enable_predictive_optimization
+        if self.isolation_mode is not None: body['isolation_mode'] = self.isolation_mode
+        if self.name is not None: body['name'] = self.name
+        if self.new_name is not None: body['new_name'] = self.new_name
+        if self.owner is not None: body['owner'] = self.owner
+        if self.properties: body['properties'] = self.properties
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateCatalog:
         """Deserializes the UpdateCatalog from a dictionary."""
@@ -5644,6 +7157,15 @@ class UpdateConnection:
         if self.owner is not None: body['owner'] = self.owner
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateConnection into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.name is not None: body['name'] = self.name
+        if self.new_name is not None: body['new_name'] = self.new_name
+        if self.options: body['options'] = self.options
+        if self.owner is not None: body['owner'] = self.owner
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateConnection:
         """Deserializes the UpdateConnection from a dictionary."""
@@ -5661,11 +7183,18 @@ class UpdateCredentialRequest:
     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**."""
+
     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."""
+
     force: Optional[bool] = None
-    """Force update even if there are dependent services."""
+    """Force an update even if there are dependent services (when purpose is **SERVICE**) or dependent
+    external locations and external tables (when purpose is **STORAGE**)."""
 
     isolation_mode: Optional[IsolationMode] = None
     """Whether the current securable is accessible from all workspaces or a specific set of workspaces."""
@@ -5679,6 +7208,10 @@ class UpdateCredentialRequest:
     owner: Optional[str] = None
     """Username of current owner of credential."""
 
+    read_only: Optional[bool] = None
+    """Whether the credential is usable only for read operations. Only applicable when purpose is
+    **STORAGE**."""
+
     skip_validation: Optional[bool] = None
     """Supply true to this argument to skip validation of the updated credential."""
 
@@ -5687,12 +7220,35 @@ class UpdateCredentialRequest:
         body = {}
         if self.aws_iam_role: body['aws_iam_role'] = self.aws_iam_role.as_dict()
         if self.azure_managed_identity: body['azure_managed_identity'] = self.azure_managed_identity.as_dict()
+        if self.azure_service_principal:
+            body['azure_service_principal'] = self.azure_service_principal.as_dict()
         if self.comment is not None: body['comment'] = self.comment
+        if self.databricks_gcp_service_account:
+            body['databricks_gcp_service_account'] = self.databricks_gcp_service_account.as_dict()
         if self.force is not None: body['force'] = self.force
         if self.isolation_mode is not None: body['isolation_mode'] = self.isolation_mode.value
         if self.name_arg is not None: body['name_arg'] = self.name_arg
         if self.new_name is not None: body['new_name'] = self.new_name
         if self.owner is not None: body['owner'] = self.owner
+        if self.read_only is not None: body['read_only'] = self.read_only
+        if self.skip_validation is not None: body['skip_validation'] = self.skip_validation
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateCredentialRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.aws_iam_role: body['aws_iam_role'] = self.aws_iam_role
+        if self.azure_managed_identity: body['azure_managed_identity'] = self.azure_managed_identity
+        if self.azure_service_principal: body['azure_service_principal'] = self.azure_service_principal
+        if self.comment is not None: body['comment'] = self.comment
+        if self.databricks_gcp_service_account:
+            body['databricks_gcp_service_account'] = self.databricks_gcp_service_account
+        if self.force is not None: body['force'] = self.force
+        if self.isolation_mode is not None: body['isolation_mode'] = self.isolation_mode
+        if self.name_arg is not None: body['name_arg'] = self.name_arg
+        if self.new_name is not None: body['new_name'] = self.new_name
+        if self.owner is not None: body['owner'] = self.owner
+        if self.read_only is not None: body['read_only'] = self.read_only
         if self.skip_validation is not None: body['skip_validation'] = self.skip_validation
         return body
 
@@ -5701,12 +7257,16 @@ class UpdateCredentialRequest:
         """Deserializes the UpdateCredentialRequest from a dictionary."""
         return cls(aws_iam_role=_from_dict(d, 'aws_iam_role', AwsIamRole),
                    azure_managed_identity=_from_dict(d, 'azure_managed_identity', AzureManagedIdentity),
+                   azure_service_principal=_from_dict(d, 'azure_service_principal', AzureServicePrincipal),
                    comment=d.get('comment', None),
+                   databricks_gcp_service_account=_from_dict(d, 'databricks_gcp_service_account',
+                                                             DatabricksGcpServiceAccount),
                    force=d.get('force', None),
                    isolation_mode=_enum(d, 'isolation_mode', IsolationMode),
                    name_arg=d.get('name_arg', None),
                    new_name=d.get('new_name', None),
                    owner=d.get('owner', None),
+                   read_only=d.get('read_only', None),
                    skip_validation=d.get('skip_validation', None))
 
 
@@ -5770,6 +7330,24 @@ class UpdateExternalLocation:
         if self.url is not None: body['url'] = self.url
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateExternalLocation into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.access_point is not None: body['access_point'] = self.access_point
+        if self.comment is not None: body['comment'] = self.comment
+        if self.credential_name is not None: body['credential_name'] = self.credential_name
+        if self.encryption_details: body['encryption_details'] = self.encryption_details
+        if self.fallback is not None: body['fallback'] = self.fallback
+        if self.force is not None: body['force'] = self.force
+        if self.isolation_mode is not None: body['isolation_mode'] = self.isolation_mode
+        if self.name is not None: body['name'] = self.name
+        if self.new_name is not None: body['new_name'] = self.new_name
+        if self.owner is not None: body['owner'] = self.owner
+        if self.read_only is not None: body['read_only'] = self.read_only
+        if self.skip_validation is not None: body['skip_validation'] = self.skip_validation
+        if self.url is not None: body['url'] = self.url
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateExternalLocation:
         """Deserializes the UpdateExternalLocation from a dictionary."""
@@ -5804,6 +7382,13 @@ class UpdateFunction:
         if self.owner is not None: body['owner'] = self.owner
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateFunction into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.name is not None: body['name'] = self.name
+        if self.owner is not None: body['owner'] = self.owner
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateFunction:
         """Deserializes the UpdateFunction from a dictionary."""
@@ -5855,6 +7440,24 @@ class UpdateMetastore:
             body['storage_root_credential_id'] = self.storage_root_credential_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateMetastore into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.delta_sharing_organization_name is not None:
+            body['delta_sharing_organization_name'] = self.delta_sharing_organization_name
+        if self.delta_sharing_recipient_token_lifetime_in_seconds is not None:
+            body[
+                'delta_sharing_recipient_token_lifetime_in_seconds'] = self.delta_sharing_recipient_token_lifetime_in_seconds
+        if self.delta_sharing_scope is not None: body['delta_sharing_scope'] = self.delta_sharing_scope
+        if self.id is not None: body['id'] = self.id
+        if self.new_name is not None: body['new_name'] = self.new_name
+        if self.owner is not None: body['owner'] = self.owner
+        if self.privilege_model_version is not None:
+            body['privilege_model_version'] = self.privilege_model_version
+        if self.storage_root_credential_id is not None:
+            body['storage_root_credential_id'] = self.storage_root_credential_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateMetastore:
         """Deserializes the UpdateMetastore from a dictionary."""
@@ -5889,6 +7492,14 @@ class UpdateMetastoreAssignment:
         if self.workspace_id is not None: body['workspace_id'] = self.workspace_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateMetastoreAssignment into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.default_catalog_name is not None: body['default_catalog_name'] = self.default_catalog_name
+        if self.metastore_id is not None: body['metastore_id'] = self.metastore_id
+        if self.workspace_id is not None: body['workspace_id'] = self.workspace_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateMetastoreAssignment:
         """Deserializes the UpdateMetastoreAssignment from a dictionary."""
@@ -5923,6 +7534,14 @@ class UpdateModelVersionRequest:
         if self.version is not None: body['version'] = self.version
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateModelVersionRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.comment is not None: body['comment'] = self.comment
+        if self.full_name is not None: body['full_name'] = self.full_name
+        if self.version is not None: body['version'] = self.version
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateModelVersionRequest:
         """Deserializes the UpdateModelVersionRequest from a dictionary."""
@@ -5993,6 +7612,24 @@ class UpdateMonitor:
         if self.time_series: body['time_series'] = self.time_series.as_dict()
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateMonitor into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.baseline_table_name is not None: body['baseline_table_name'] = self.baseline_table_name
+        if self.custom_metrics: body['custom_metrics'] = self.custom_metrics
+        if self.dashboard_id is not None: body['dashboard_id'] = self.dashboard_id
+        if self.data_classification_config:
+            body['data_classification_config'] = self.data_classification_config
+        if self.inference_log: body['inference_log'] = self.inference_log
+        if self.notifications: body['notifications'] = self.notifications
+        if self.output_schema_name is not None: body['output_schema_name'] = self.output_schema_name
+        if self.schedule: body['schedule'] = self.schedule
+        if self.slicing_exprs: body['slicing_exprs'] = self.slicing_exprs
+        if self.snapshot: body['snapshot'] = self.snapshot
+        if self.table_name is not None: body['table_name'] = self.table_name
+        if self.time_series: body['time_series'] = self.time_series
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateMonitor:
         """Deserializes the UpdateMonitor from a dictionary."""
@@ -6030,6 +7667,14 @@ class UpdatePermissions:
         if self.securable_type is not None: body['securable_type'] = self.securable_type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdatePermissions into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.changes: body['changes'] = self.changes
+        if self.full_name is not None: body['full_name'] = self.full_name
+        if self.securable_type is not None: body['securable_type'] = self.securable_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdatePermissions:
         """Deserializes the UpdatePermissions from a dictionary."""
@@ -6061,6 +7706,15 @@ class UpdateRegisteredModelRequest:
         if self.owner is not None: body['owner'] = self.owner
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateRegisteredModelRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.comment is not None: body['comment'] = self.comment
+        if self.full_name is not None: body['full_name'] = self.full_name
+        if self.new_name is not None: body['new_name'] = self.new_name
+        if self.owner is not None: body['owner'] = self.owner
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateRegisteredModelRequest:
         """Deserializes the UpdateRegisteredModelRequest from a dictionary."""
@@ -6078,6 +7732,11 @@ class UpdateResponse:
         body = {}
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateResponse:
         """Deserializes the UpdateResponse from a dictionary."""
@@ -6116,6 +7775,18 @@ class UpdateSchema:
         if self.properties: body['properties'] = self.properties
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateSchema into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.comment is not None: body['comment'] = self.comment
+        if self.enable_predictive_optimization is not None:
+            body['enable_predictive_optimization'] = self.enable_predictive_optimization
+        if self.full_name is not None: body['full_name'] = self.full_name
+        if self.new_name is not None: body['new_name'] = self.new_name
+        if self.owner is not None: body['owner'] = self.owner
+        if self.properties: body['properties'] = self.properties
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateSchema:
         """Deserializes the UpdateSchema from a dictionary."""
@@ -6188,6 +7859,25 @@ class UpdateStorageCredential:
         if self.skip_validation is not None: body['skip_validation'] = self.skip_validation
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateStorageCredential into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.aws_iam_role: body['aws_iam_role'] = self.aws_iam_role
+        if self.azure_managed_identity: body['azure_managed_identity'] = self.azure_managed_identity
+        if self.azure_service_principal: body['azure_service_principal'] = self.azure_service_principal
+        if self.cloudflare_api_token: body['cloudflare_api_token'] = self.cloudflare_api_token
+        if self.comment is not None: body['comment'] = self.comment
+        if self.databricks_gcp_service_account:
+            body['databricks_gcp_service_account'] = self.databricks_gcp_service_account
+        if self.force is not None: body['force'] = self.force
+        if self.isolation_mode is not None: body['isolation_mode'] = self.isolation_mode
+        if self.name is not None: body['name'] = self.name
+        if self.new_name is not None: body['new_name'] = self.new_name
+        if self.owner is not None: body['owner'] = self.owner
+        if self.read_only is not None: body['read_only'] = self.read_only
+        if self.skip_validation is not None: body['skip_validation'] = self.skip_validation
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateStorageCredential:
         """Deserializes the UpdateStorageCredential from a dictionary."""
@@ -6231,6 +7921,15 @@ class UpdateVolumeRequestContent:
         if self.owner is not None: body['owner'] = self.owner
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateVolumeRequestContent into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.comment is not None: body['comment'] = self.comment
+        if self.name is not None: body['name'] = self.name
+        if self.new_name is not None: body['new_name'] = self.new_name
+        if self.owner is not None: body['owner'] = self.owner
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateVolumeRequestContent:
         """Deserializes the UpdateVolumeRequestContent from a dictionary."""
@@ -6259,6 +7958,14 @@ class UpdateWorkspaceBindings:
         if self.unassign_workspaces: body['unassign_workspaces'] = [v for v in self.unassign_workspaces]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateWorkspaceBindings into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.assign_workspaces: body['assign_workspaces'] = self.assign_workspaces
+        if self.name is not None: body['name'] = self.name
+        if self.unassign_workspaces: body['unassign_workspaces'] = self.unassign_workspaces
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateWorkspaceBindings:
         """Deserializes the UpdateWorkspaceBindings from a dictionary."""
@@ -6290,6 +7997,15 @@ class UpdateWorkspaceBindingsParameters:
         if self.securable_type is not None: body['securable_type'] = self.securable_type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the UpdateWorkspaceBindingsParameters into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.add: body['add'] = self.add
+        if self.remove: body['remove'] = self.remove
+        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
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> UpdateWorkspaceBindingsParameters:
         """Deserializes the UpdateWorkspaceBindingsParameters from a dictionary."""
@@ -6310,16 +8026,44 @@ class ValidateCredentialRequest:
     credential_name: Optional[str] = None
     """Required. The name of an existing credential or long-lived cloud credential to validate."""
 
+    external_location_name: Optional[str] = None
+    """The name of an existing external location to validate. Only applicable for storage credentials
+    (purpose is **STORAGE**.)"""
+
     purpose: Optional[CredentialPurpose] = None
     """The purpose of the credential. This should only be used when the credential is specified."""
 
+    read_only: Optional[bool] = None
+    """Whether the credential is only usable for read operations. Only applicable for storage
+    credentials (purpose is **STORAGE**.)"""
+
+    url: Optional[str] = None
+    """The external location url to validate. Only applicable when purpose is **STORAGE**."""
+
     def as_dict(self) -> dict:
         """Serializes the ValidateCredentialRequest into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.aws_iam_role: body['aws_iam_role'] = self.aws_iam_role.as_dict()
         if self.azure_managed_identity: body['azure_managed_identity'] = self.azure_managed_identity.as_dict()
         if self.credential_name is not None: body['credential_name'] = self.credential_name
+        if self.external_location_name is not None:
+            body['external_location_name'] = self.external_location_name
         if self.purpose is not None: body['purpose'] = self.purpose.value
+        if self.read_only is not None: body['read_only'] = self.read_only
+        if self.url is not None: body['url'] = self.url
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ValidateCredentialRequest into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.aws_iam_role: body['aws_iam_role'] = self.aws_iam_role
+        if self.azure_managed_identity: body['azure_managed_identity'] = self.azure_managed_identity
+        if self.credential_name is not None: body['credential_name'] = self.credential_name
+        if self.external_location_name is not None:
+            body['external_location_name'] = self.external_location_name
+        if self.purpose is not None: body['purpose'] = self.purpose
+        if self.read_only is not None: body['read_only'] = self.read_only
+        if self.url is not None: body['url'] = self.url
         return body
 
     @classmethod
@@ -6328,24 +8072,40 @@ class ValidateCredentialRequest:
         return cls(aws_iam_role=_from_dict(d, 'aws_iam_role', AwsIamRole),
                    azure_managed_identity=_from_dict(d, 'azure_managed_identity', AzureManagedIdentity),
                    credential_name=d.get('credential_name', None),
-                   purpose=_enum(d, 'purpose', CredentialPurpose))
+                   external_location_name=d.get('external_location_name', None),
+                   purpose=_enum(d, 'purpose', CredentialPurpose),
+                   read_only=d.get('read_only', None),
+                   url=d.get('url', None))
 
 
 @dataclass
 class ValidateCredentialResponse:
+    is_dir: Optional[bool] = None
+    """Whether the tested location is a directory in cloud storage. Only applicable for when purpose is
+    **STORAGE**."""
+
     results: Optional[List[CredentialValidationResult]] = None
     """The results of the validation check."""
 
     def as_dict(self) -> dict:
         """Serializes the ValidateCredentialResponse into a dictionary suitable for use as a JSON request body."""
         body = {}
+        if self.is_dir is not None: body['isDir'] = self.is_dir
         if self.results: body['results'] = [v.as_dict() for v in self.results]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ValidateCredentialResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.is_dir is not None: body['isDir'] = self.is_dir
+        if self.results: body['results'] = self.results
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ValidateCredentialResponse:
         """Deserializes the ValidateCredentialResponse from a dictionary."""
-        return cls(results=_repeated_dict(d, 'results', CredentialValidationResult))
+        return cls(is_dir=d.get('isDir', None),
+                   results=_repeated_dict(d, 'results', CredentialValidationResult))
 
 
 class ValidateCredentialResult(Enum):
@@ -6403,6 +8163,23 @@ class ValidateStorageCredential:
         if self.url is not None: body['url'] = self.url
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ValidateStorageCredential into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.aws_iam_role: body['aws_iam_role'] = self.aws_iam_role
+        if self.azure_managed_identity: body['azure_managed_identity'] = self.azure_managed_identity
+        if self.azure_service_principal: body['azure_service_principal'] = self.azure_service_principal
+        if self.cloudflare_api_token: body['cloudflare_api_token'] = self.cloudflare_api_token
+        if self.databricks_gcp_service_account:
+            body['databricks_gcp_service_account'] = self.databricks_gcp_service_account
+        if self.external_location_name is not None:
+            body['external_location_name'] = self.external_location_name
+        if self.read_only is not None: body['read_only'] = self.read_only
+        if self.storage_credential_name is not None:
+            body['storage_credential_name'] = self.storage_credential_name
+        if self.url is not None: body['url'] = self.url
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ValidateStorageCredential:
         """Deserializes the ValidateStorageCredential from a dictionary."""
@@ -6434,6 +8211,13 @@ class ValidateStorageCredentialResponse:
         if self.results: body['results'] = [v.as_dict() for v in self.results]
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ValidateStorageCredentialResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.is_dir is not None: body['isDir'] = self.is_dir
+        if self.results: body['results'] = self.results
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ValidateStorageCredentialResponse:
         """Deserializes the ValidateStorageCredentialResponse from a dictionary."""
@@ -6459,6 +8243,14 @@ class ValidationResult:
         if self.result is not None: body['result'] = self.result.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the ValidationResult into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.message is not None: body['message'] = self.message
+        if self.operation is not None: body['operation'] = self.operation
+        if self.result is not None: body['result'] = self.result
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> ValidationResult:
         """Deserializes the ValidationResult from a dictionary."""
@@ -6558,6 +8350,28 @@ class VolumeInfo:
         if self.volume_type is not None: body['volume_type'] = self.volume_type.value
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the VolumeInfo into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.access_point is not None: body['access_point'] = self.access_point
+        if self.browse_only is not None: body['browse_only'] = self.browse_only
+        if self.catalog_name is not None: body['catalog_name'] = self.catalog_name
+        if self.comment is not None: body['comment'] = self.comment
+        if self.created_at is not None: body['created_at'] = self.created_at
+        if self.created_by is not None: body['created_by'] = self.created_by
+        if self.encryption_details: body['encryption_details'] = self.encryption_details
+        if self.full_name is not None: body['full_name'] = self.full_name
+        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.schema_name is not None: body['schema_name'] = self.schema_name
+        if self.storage_location is not None: body['storage_location'] = self.storage_location
+        if self.updated_at is not None: body['updated_at'] = self.updated_at
+        if self.updated_by is not None: body['updated_by'] = self.updated_by
+        if self.volume_id is not None: body['volume_id'] = self.volume_id
+        if self.volume_type is not None: body['volume_type'] = self.volume_type
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> VolumeInfo:
         """Deserializes the VolumeInfo from a dictionary."""
@@ -6599,6 +8413,13 @@ class WorkspaceBinding:
         if self.workspace_id is not None: body['workspace_id'] = self.workspace_id
         return body
 
+    def as_shallow_dict(self) -> dict:
+        """Serializes the WorkspaceBinding into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.binding_type is not None: body['binding_type'] = self.binding_type
+        if self.workspace_id is not None: body['workspace_id'] = self.workspace_id
+        return body
+
     @classmethod
     def from_dict(cls, d: Dict[str, any]) -> WorkspaceBinding:
         """Deserializes the WorkspaceBinding from a dictionary."""
@@ -6630,6 +8451,13 @@ class WorkspaceBindingsResponse:
         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 WorkspaceBindingsResponse into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.bindings: body['bindings'] = self.bindings
+        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]) -> WorkspaceBindingsResponse:
         """Deserializes the WorkspaceBindingsResponse from a dictionary."""
@@ -7397,36 +9225,50 @@ class CredentialsAPI:
     tenant. Each credential is subject to Unity Catalog access-control policies that control which users and
     groups can access the credential.
     
-    To create credentials, you must be a Databricks account admin or have the `CREATE SERVICE CREDENTIAL
+    To create credentials, you must be a Databricks account admin or have the `CREATE SERVICE CREDENTIAL`
     privilege. The user who creates the credential can delegate ownership to another user or group to manage
-    permissions on it"""
+    permissions on it."""
 
     def __init__(self, api_client):
         self._api = api_client
 
     def create_credential(self,
+                          name: str,
                           *,
                           aws_iam_role: Optional[AwsIamRole] = None,
                           azure_managed_identity: Optional[AzureManagedIdentity] = None,
+                          azure_service_principal: Optional[AzureServicePrincipal] = None,
                           comment: Optional[str] = None,
-                          name: Optional[str] = None,
+                          databricks_gcp_service_account: Optional[DatabricksGcpServiceAccount] = None,
                           purpose: Optional[CredentialPurpose] = None,
+                          read_only: Optional[bool] = None,
                           skip_validation: Optional[bool] = None) -> CredentialInfo:
         """Create a credential.
         
-        Creates a new credential.
+        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
+        storage credentials, or **CREATE_SERVICE_CREDENTIAL** for service credentials.
+        
+        :param name: str
+          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
         :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**.
         :param comment: str (optional)
           Comment associated with the credential.
-        :param name: str (optional)
-          The credential name. The name must be unique among storage and service credentials within the
-          metastore.
+        :param databricks_gcp_service_account: :class:`DatabricksGcpServiceAccount` (optional)
+          GCP long-lived credential. Databricks-created Google Cloud Storage service account.
         :param purpose: :class:`CredentialPurpose` (optional)
           Indicates the purpose of the credential.
+        :param read_only: bool (optional)
+          Whether the credential is usable only for read operations. Only applicable when purpose is
+          **STORAGE**.
         :param skip_validation: bool (optional)
           Optional. Supplying true to this argument skips validation of the created set of credentials.
         
@@ -7436,9 +9278,14 @@ class CredentialsAPI:
         if aws_iam_role is not None: body['aws_iam_role'] = aws_iam_role.as_dict()
         if azure_managed_identity is not None:
             body['azure_managed_identity'] = azure_managed_identity.as_dict()
+        if azure_service_principal is not None:
+            body['azure_service_principal'] = azure_service_principal.as_dict()
         if comment is not None: body['comment'] = comment
+        if databricks_gcp_service_account is not None:
+            body['databricks_gcp_service_account'] = databricks_gcp_service_account.as_dict()
         if name is not None: body['name'] = name
         if purpose is not None: body['purpose'] = purpose.value
+        if read_only is not None: body['read_only'] = read_only
         if skip_validation is not None: body['skip_validation'] = skip_validation
         headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
@@ -7448,12 +9295,14 @@ class CredentialsAPI:
     def delete_credential(self, name_arg: str, *, force: Optional[bool] = None):
         """Delete a credential.
         
-        Deletes a credential from the metastore. The caller must be an owner of the credential.
+        Deletes a service or storage credential from the metastore. The caller must be an owner of the
+        credential.
         
         :param name_arg: str
           Name of the credential.
         :param force: bool (optional)
-          Force deletion even if there are dependent services.
+          Force an update even if there are dependent services (when purpose is **SERVICE**) or dependent
+          external locations and external tables (when purpose is **STORAGE**).
         
         
         """
@@ -7466,24 +9315,29 @@ class CredentialsAPI:
 
     def generate_temporary_service_credential(
             self,
+            credential_name: str,
             *,
             azure_options: Optional[GenerateTemporaryServiceCredentialAzureOptions] = None,
-            credential_name: Optional[str] = None) -> TemporaryCredentials:
+            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
         must be a metastore admin or have the metastore privilege **ACCESS** on the service credential.
         
-        :param azure_options: :class:`GenerateTemporaryServiceCredentialAzureOptions` (optional)
-          Options to customize the requested temporary credential
-        :param credential_name: str (optional)
+        :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`
         """
         body = {}
         if azure_options is not None: body['azure_options'] = azure_options.as_dict()
         if credential_name is not None: body['credential_name'] = credential_name
+        if gcp_options is not None: body['gcp_options'] = gcp_options.as_dict()
         headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
         res = self._api.do('POST',
@@ -7495,8 +9349,8 @@ class CredentialsAPI:
     def get_credential(self, name_arg: str) -> CredentialInfo:
         """Get a credential.
         
-        Gets a credential from the metastore. The caller must be a metastore admin, the owner of the
-        credential, or have any permission on the credential.
+        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
           Name of the credential.
@@ -7555,15 +9409,18 @@ class CredentialsAPI:
                           *,
                           aws_iam_role: Optional[AwsIamRole] = None,
                           azure_managed_identity: Optional[AzureManagedIdentity] = None,
+                          azure_service_principal: Optional[AzureServicePrincipal] = None,
                           comment: Optional[str] = None,
+                          databricks_gcp_service_account: Optional[DatabricksGcpServiceAccount] = None,
                           force: Optional[bool] = None,
                           isolation_mode: Optional[IsolationMode] = None,
                           new_name: Optional[str] = None,
                           owner: Optional[str] = None,
+                          read_only: Optional[bool] = None,
                           skip_validation: Optional[bool] = None) -> CredentialInfo:
         """Update a credential.
         
-        Updates a 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.
@@ -7574,16 +9431,24 @@ class CredentialsAPI:
           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**.
         :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.
         :param force: bool (optional)
-          Force update even if there are dependent services.
+          Force an update even if there are dependent services (when purpose is **SERVICE**) or dependent
+          external locations and external tables (when purpose is **STORAGE**).
         :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 of credential.
         :param owner: str (optional)
           Username of current owner of credential.
+        :param read_only: bool (optional)
+          Whether the credential is usable only for read operations. Only applicable when purpose is
+          **STORAGE**.
         :param skip_validation: bool (optional)
           Supply true to this argument to skip validation of the updated credential.
         
@@ -7593,11 +9458,16 @@ class CredentialsAPI:
         if aws_iam_role is not None: body['aws_iam_role'] = aws_iam_role.as_dict()
         if azure_managed_identity is not None:
             body['azure_managed_identity'] = azure_managed_identity.as_dict()
+        if azure_service_principal is not None:
+            body['azure_service_principal'] = azure_service_principal.as_dict()
         if comment is not None: body['comment'] = comment
+        if databricks_gcp_service_account is not None:
+            body['databricks_gcp_service_account'] = databricks_gcp_service_account.as_dict()
         if force is not None: body['force'] = force
         if isolation_mode is not None: body['isolation_mode'] = isolation_mode.value
         if new_name is not None: body['new_name'] = new_name
         if owner is not None: body['owner'] = owner
+        if read_only is not None: body['read_only'] = read_only
         if skip_validation is not None: body['skip_validation'] = skip_validation
         headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
@@ -7612,14 +9482,25 @@ class CredentialsAPI:
                             aws_iam_role: Optional[AwsIamRole] = None,
                             azure_managed_identity: Optional[AzureManagedIdentity] = None,
                             credential_name: Optional[str] = None,
-                            purpose: Optional[CredentialPurpose] = None) -> ValidateCredentialResponse:
+                            external_location_name: Optional[str] = None,
+                            purpose: Optional[CredentialPurpose] = None,
+                            read_only: Optional[bool] = None,
+                            url: Optional[str] = None) -> ValidateCredentialResponse:
         """Validate a credential.
         
         Validates a credential.
         
-        Either the __credential_name__ or the cloud-specific credential must be provided.
+        For service credentials (purpose is **SERVICE**), either the __credential_name__ or the cloud-specific
+        credential must be provided.
+        
+        For storage credentials (purpose is **STORAGE**), 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. Either the __credential_name__ or the cloud-specific
+        credential must be provided.
         
-        The caller must be a metastore admin or the credential owner.
+        The caller must be a metastore admin or the credential owner or have the required permission on the
+        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
@@ -7627,8 +9508,16 @@ class CredentialsAPI:
           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 external_location_name: str (optional)
+          The name of an existing external location to validate. Only applicable for storage credentials
+          (purpose is **STORAGE**.)
         :param purpose: :class:`CredentialPurpose` (optional)
           The purpose of the credential. This should only be used when the credential is specified.
+        :param read_only: bool (optional)
+          Whether the credential is only usable for read operations. Only applicable for storage credentials
+          (purpose is **STORAGE**.)
+        :param url: str (optional)
+          The external location url to validate. Only applicable when purpose is **STORAGE**.
         
         :returns: :class:`ValidateCredentialResponse`
         """
@@ -7637,7 +9526,10 @@ class CredentialsAPI:
         if azure_managed_identity is not None:
             body['azure_managed_identity'] = azure_managed_identity.as_dict()
         if credential_name is not None: body['credential_name'] = credential_name
+        if external_location_name is not None: body['external_location_name'] = external_location_name
         if purpose is not None: body['purpose'] = purpose.value
+        if read_only is not None: body['read_only'] = read_only
+        if url is not None: body['url'] = url
         headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
         res = self._api.do('POST', '/api/2.1/unity-catalog/validate-credentials', body=body, headers=headers)
@@ -8640,7 +10532,7 @@ class OnlineTablesAPI:
           Long-running operation waiter for :class:`OnlineTable`.
           See :method:wait_get_online_table_active for more details.
         """
-        body = table
+        body = table.as_dict()
         headers = {'Accept': 'application/json', 'Content-Type': 'application/json', }
 
         op_response = self._api.do('POST', '/api/2.0/online-tables', body=body, headers=headers)
@@ -10128,6 +12020,7 @@ class TablesAPI:
              max_results: Optional[int] = None,
              omit_columns: Optional[bool] = None,
              omit_properties: Optional[bool] = None,
+             omit_username: Optional[bool] = None,
              page_token: Optional[str] = None) -> Iterator[TableInfo]:
         """List tables.
         
@@ -10157,6 +12050,9 @@ class TablesAPI:
           Whether to omit the columns of the table from the response or not.
         :param omit_properties: bool (optional)
           Whether to omit the properties of the table from the response or not.
+        :param omit_username: bool (optional)
+          Whether to omit the username of the table (e.g. owner, updated_by, created_by) from the response or
+          not.
         :param page_token: str (optional)
           Opaque token to send for the next page of results (pagination).
         
@@ -10172,6 +12068,7 @@ class TablesAPI:
         if max_results is not None: query['max_results'] = max_results
         if omit_columns is not None: query['omit_columns'] = omit_columns
         if omit_properties is not None: query['omit_properties'] = omit_properties
+        if omit_username is not None: query['omit_username'] = omit_username
         if page_token is not None: query['page_token'] = page_token
         if schema_name is not None: query['schema_name'] = schema_name
         headers = {'Accept': 'application/json', }