msgraph-sdk 1.35.0__py3-none-any.whl → 1.37.0__py3-none-any.whl

msgraph/generated/kiota-lock.json

@@ -1,5 +1,5 @@
 {
-  "descriptionHash": "B06ED628E27AAD8F8ED2E3AA49DEE5FF10E6F211237E90896666FA008F5885D429DD2685B8462C401CA04D6A3B5EE90DB71E7AD795881A9E1DCF7E3E76C64270",
+  "descriptionHash": "645999DA4E657EB400D8A694456CA5F9D1E62FE46056F8B00797AD20C48BFD4522A925588EF4DD2AD33AE76361C65DDDEDB5C4C77BE6167C97F26B389CDD0E3D",
   "descriptionLocation": "../../msgraph-metadata/clean_v10_openapi/openapi.yaml",
   "lockFileVersion": "1.0.0",
   "kiotaVersion": "1.28.0",

msgraph/generated/models/activities_container.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .content_activity import ContentActivity
+    from .entity import Entity
+
+from .entity import Entity
+
+@dataclass
+class ActivitiesContainer(Entity, Parsable):
+    # Collection of activity logs related to content processing.
+    content_activities: Optional[list[ContentActivity]] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ActivitiesContainer:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: ActivitiesContainer
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ActivitiesContainer()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .content_activity import ContentActivity
+        from .entity import Entity
+
+        from .content_activity import ContentActivity
+        from .entity import Entity
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "contentActivities": lambda n : setattr(self, 'content_activities', n.get_collection_of_object_values(ContentActivity)),
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+        writer.write_collection_of_object_values("contentActivities", self.content_activities)
+    
+

msgraph/generated/models/activity_metadata.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from kiota_abstractions.store import BackedModel, BackingStore, BackingStoreFactorySingleton
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .user_activity_type import UserActivityType
+
+@dataclass
+class ActivityMetadata(AdditionalDataHolder, BackedModel, Parsable):
+    # Stores model information.
+    backing_store: BackingStore = field(default_factory=BackingStoreFactorySingleton(backing_store_factory=None).backing_store_factory.create_backing_store, repr=False)
+
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+    # The activity property
+    activity: Optional[UserActivityType] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ActivityMetadata:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: ActivityMetadata
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ActivityMetadata()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .user_activity_type import UserActivityType
+
+        from .user_activity_type import UserActivityType
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "activity": lambda n : setattr(self, 'activity', n.get_enum_value(UserActivityType)),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_enum_value("activity", self.activity)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/administrative_unit.py

@@ -21,7 +21,7 @@ class AdministrativeUnit(DirectoryObject, Parsable):
     display_name: Optional[str] = None
     # The collection of open extensions defined for this administrative unit. Nullable.
     extensions: Optional[list[Extension]] = None
-    # The isMemberManagementRestricted property
+    # true if members of this administrative unit should be treated as sensitive, which requires specific permissions to manage. If not set, the default value is null and the default behavior is false. Use this property to define administrative units with roles that don't inherit from tenant-level administrators, and where the management of individual member objects is limited to administrators scoped to a restricted management administrative unit. This property is immutable and can't be changed later.  For more information on how to work with restricted management administrative units, see Restricted management administrative units in Microsoft Entra ID.
     is_member_management_restricted: Optional[bool] = None
     # Users and groups that are members of this administrative unit. Supports $expand.
     members: Optional[list[DirectoryObject]] = None

msgraph/generated/models/ai_interaction_plugin.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from kiota_abstractions.store import BackedModel, BackingStore, BackingStoreFactorySingleton
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+@dataclass
+class AiInteractionPlugin(AdditionalDataHolder, BackedModel, Parsable):
+    # Stores model information.
+    backing_store: BackingStore = field(default_factory=BackingStoreFactorySingleton(backing_store_factory=None).backing_store_factory.create_backing_store, repr=False)
+
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+    # The unique identifier of the plugin.
+    identifier: Optional[str] = None
+    # The display name of the plugin.
+    name: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The version of the plugin used.
+    version: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AiInteractionPlugin:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: AiInteractionPlugin
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AiInteractionPlugin()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        fields: dict[str, Callable[[Any], None]] = {
+            "identifier": lambda n : setattr(self, 'identifier', n.get_str_value()),
+            "name": lambda n : setattr(self, 'name', n.get_str_value()),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "version": lambda n : setattr(self, 'version', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("identifier", self.identifier)
+        writer.write_str_value("name", self.name)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_str_value("version", self.version)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/binary_content.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .content_base import ContentBase
+
+from .content_base import ContentBase
+
+@dataclass
+class BinaryContent(ContentBase, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.binaryContent"
+    # The binary content, encoded as a Base64 string. Inherited from contentBase.
+    data: Optional[bytes] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> BinaryContent:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: BinaryContent
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return BinaryContent()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .content_base import ContentBase
+
+        from .content_base import ContentBase
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "data": lambda n : setattr(self, 'data', n.get_bytes_value()),
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+        writer.write_bytes_value("data", self.data)
+    
+

msgraph/generated/models/call_event.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+import datetime
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .call_event_type import CallEventType
+    from .emergency_call_event import EmergencyCallEvent
+    from .entity import Entity
+    from .participant import Participant
+
+from .entity import Entity
+
+@dataclass
+class CallEvent(Entity, Parsable):
+    # The callEventType property
+    call_event_type: Optional[CallEventType] = None
+    # The eventDateTime property
+    event_date_time: Optional[datetime.datetime] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The participants property
+    participants: Optional[list[Participant]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> CallEvent:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: CallEvent
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        try:
+            child_node = parse_node.get_child_node("@odata.type")
+            mapping_value = child_node.get_str_value() if child_node else None
+        except AttributeError:
+            mapping_value = None
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.emergencyCallEvent".casefold():
+            from .emergency_call_event import EmergencyCallEvent
+
+            return EmergencyCallEvent()
+        return CallEvent()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .call_event_type import CallEventType
+        from .emergency_call_event import EmergencyCallEvent
+        from .entity import Entity
+        from .participant import Participant
+
+        from .call_event_type import CallEventType
+        from .emergency_call_event import EmergencyCallEvent
+        from .entity import Entity
+        from .participant import Participant
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "callEventType": lambda n : setattr(self, 'call_event_type', n.get_enum_value(CallEventType)),
+            "eventDateTime": lambda n : setattr(self, 'event_date_time', n.get_datetime_value()),
+            "participants": lambda n : setattr(self, 'participants', n.get_collection_of_object_values(Participant)),
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+        writer.write_enum_value("callEventType", self.call_event_type)
+        writer.write_datetime_value("eventDateTime", self.event_date_time)
+        writer.write_collection_of_object_values("participants", self.participants)
+    
+

msgraph/generated/models/call_event_type.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class CallEventType(str, Enum):
+    CallStarted = "callStarted",
+    CallEnded = "callEnded",
+    UnknownFutureValue = "unknownFutureValue",
+    RosterUpdated = "rosterUpdated",
+

msgraph/generated/models/certificate_authority_detail.py

@@ -15,27 +15,27 @@ from .directory_object import DirectoryObject
 class CertificateAuthorityDetail(DirectoryObject, Parsable):
     # The OdataType property
     odata_type: Optional[str] = "#microsoft.graph.certificateAuthorityDetail"
-    # The certificate property
+    # The public key of the certificate authority.
     certificate: Optional[bytes] = None
-    # The certificateAuthorityType property
+    # The type of certificate authority. The possible values are: root, intermediate, unknownFutureValue. Supports $filter (eq).
     certificate_authority_type: Optional[CertificateAuthorityType] = None
-    # The certificateRevocationListUrl property
+    # The URL to check if the certificate is revoked.
     certificate_revocation_list_url: Optional[str] = None
-    # The createdDateTime property
+    # The date and time when the certificate authority was created.
     created_date_time: Optional[datetime.datetime] = None
     # The deltaCertificateRevocationListUrl property
     delta_certificate_revocation_list_url: Optional[str] = None
-    # The displayName property
+    # The display name of the certificate authority.
     display_name: Optional[str] = None
-    # The expirationDateTime property
+    # The date and time when the certificate authority expires. Supports $filter (eq) and $orderby.
     expiration_date_time: Optional[datetime.datetime] = None
-    # The isIssuerHintEnabled property
+    # Indicates whether the certificate picker presents the certificate authority to the user to use for authentication. Default value is false. Optional.
     is_issuer_hint_enabled: Optional[bool] = None
-    # The issuer property
+    # The issuer of the certificate authority.
     issuer: Optional[str] = None
-    # The issuerSubjectKeyIdentifier property
+    # The subject key identifier of certificate authority.
     issuer_subject_key_identifier: Optional[str] = None
-    # The thumbprint property
+    # The thumbprint of certificate authority certificate. Supports $filter (eq, startswith).
     thumbprint: Optional[str] = None
     
     @staticmethod

msgraph/generated/models/certificate_based_auth_pki.py

@@ -15,15 +15,15 @@ from .directory_object import DirectoryObject
 class CertificateBasedAuthPki(DirectoryObject, Parsable):
     # The OdataType property
     odata_type: Optional[str] = "#microsoft.graph.certificateBasedAuthPki"
-    # The certificateAuthorities property
+    # The collection of certificate authorities contained in this public key infrastructure resource.
     certificate_authorities: Optional[list[CertificateAuthorityDetail]] = None
-    # The displayName property
+    # The name of the object. Maximum length is 256 characters.
     display_name: Optional[str] = None
-    # The lastModifiedDateTime property
+    # The date and time when the object was created or last modified.
     last_modified_date_time: Optional[datetime.datetime] = None
-    # The status property
+    # The status of any asynchronous jobs runs on the object which can be upload or delete.
     status: Optional[str] = None
-    # The statusDetails property
+    # The status details of the upload/deleted operation of PKI (Public Key Infrastructure).
     status_details: Optional[str] = None
     
     @staticmethod

msgraph/generated/models/classifcation_error_base.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from kiota_abstractions.store import BackedModel, BackingStore, BackingStoreFactorySingleton
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .classification_error import ClassificationError
+    from .classification_inner_error import ClassificationInnerError
+    from .processing_error import ProcessingError
+
+@dataclass
+class ClassifcationErrorBase(AdditionalDataHolder, BackedModel, Parsable):
+    # Stores model information.
+    backing_store: BackingStore = field(default_factory=BackingStoreFactorySingleton(backing_store_factory=None).backing_store_factory.create_backing_store, repr=False)
+
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+    # A service-defined error code string.
+    code: Optional[str] = None
+    # Contains more specific, potentially internal error details.
+    inner_error: Optional[ClassificationInnerError] = None
+    # A human-readable representation of the error.
+    message: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The target of the error (for example, the specific property or item causing the issue).
+    target: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ClassifcationErrorBase:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: ClassifcationErrorBase
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        try:
+            child_node = parse_node.get_child_node("@odata.type")
+            mapping_value = child_node.get_str_value() if child_node else None
+        except AttributeError:
+            mapping_value = None
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.classificationError".casefold():
+            from .classification_error import ClassificationError
+
+            return ClassificationError()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.processingError".casefold():
+            from .processing_error import ProcessingError
+
+            return ProcessingError()
+        return ClassifcationErrorBase()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .classification_error import ClassificationError
+        from .classification_inner_error import ClassificationInnerError
+        from .processing_error import ProcessingError
+
+        from .classification_error import ClassificationError
+        from .classification_inner_error import ClassificationInnerError
+        from .processing_error import ProcessingError
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "code": lambda n : setattr(self, 'code', n.get_str_value()),
+            "innerError": lambda n : setattr(self, 'inner_error', n.get_object_value(ClassificationInnerError)),
+            "message": lambda n : setattr(self, 'message', n.get_str_value()),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "target": lambda n : setattr(self, 'target', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("code", self.code)
+        writer.write_object_value("innerError", self.inner_error)
+        writer.write_str_value("message", self.message)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_str_value("target", self.target)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/classification_error.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .classifcation_error_base import ClassifcationErrorBase
+    from .processing_error import ProcessingError
+
+from .classifcation_error_base import ClassifcationErrorBase
+
+@dataclass
+class ClassificationError(ClassifcationErrorBase, Parsable):
+    # A collection of more specific errors contributing to the overall error.
+    details: Optional[list[ClassifcationErrorBase]] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ClassificationError:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: ClassificationError
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        try:
+            child_node = parse_node.get_child_node("@odata.type")
+            mapping_value = child_node.get_str_value() if child_node else None
+        except AttributeError:
+            mapping_value = None
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.processingError".casefold():
+            from .processing_error import ProcessingError
+
+            return ProcessingError()
+        return ClassificationError()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .classifcation_error_base import ClassifcationErrorBase
+        from .processing_error import ProcessingError
+
+        from .classifcation_error_base import ClassifcationErrorBase
+        from .processing_error import ProcessingError
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "details": lambda n : setattr(self, 'details', n.get_collection_of_object_values(ClassifcationErrorBase)),
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+        writer.write_collection_of_object_values("details", self.details)
+    
+

msgraph/generated/models/classification_inner_error.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+import datetime
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from kiota_abstractions.store import BackedModel, BackingStore, BackingStoreFactorySingleton
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+@dataclass
+class ClassificationInnerError(AdditionalDataHolder, BackedModel, Parsable):
+    # Stores model information.
+    backing_store: BackingStore = field(default_factory=BackingStoreFactorySingleton(backing_store_factory=None).backing_store_factory.create_backing_store, repr=False)
+
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+    # The activity ID associated with the request that generated the error.
+    activity_id: Optional[str] = None
+    # The client request ID, if provided by the caller.
+    client_request_id: Optional[str] = None
+    # A more specific, potentially internal, error code string.
+    code: Optional[str] = None
+    # The date and time the inner error occurred.
+    error_date_time: Optional[datetime.datetime] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ClassificationInnerError:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: ClassificationInnerError
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ClassificationInnerError()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        fields: dict[str, Callable[[Any], None]] = {
+            "activityId": lambda n : setattr(self, 'activity_id', n.get_str_value()),
+            "clientRequestId": lambda n : setattr(self, 'client_request_id', n.get_str_value()),
+            "code": lambda n : setattr(self, 'code', n.get_str_value()),
+            "errorDateTime": lambda n : setattr(self, 'error_date_time', n.get_datetime_value()),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("activityId", self.activity_id)
+        writer.write_str_value("clientRequestId", self.client_request_id)
+        writer.write_str_value("code", self.code)
+        writer.write_datetime_value("errorDateTime", self.error_date_time)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+