msgraph-sdk 1.45.0__py3-none-any.whl → 1.47.0__py3-none-any.whl

msgraph/generated/models/education_speaker_progress_resource.py

@@ -0,0 +1,95 @@
+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 .education_ai_feedback_criteria import EducationAiFeedbackCriteria
+    from .education_resource import EducationResource
+    from .education_speaker_coach_settings import EducationSpeakerCoachSettings
+
+from .education_resource import EducationResource
+
+@dataclass
+class EducationSpeakerProgressResource(EducationResource, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.educationSpeakerProgressResource"
+    # The feedback types that students should receive from AI feedback. This property should only be provided if isAiFeedbackEnabled is true.
+    ai_feedback_criteria: Optional[EducationAiFeedbackCriteria] = None
+    # Indicates whether AI feedback is enabled for the student submissions.
+    is_ai_feedback_enabled: Optional[bool] = None
+    # Indicates whether video is required for the student recording.
+    is_video_required: Optional[bool] = None
+    # The maximum number of recording attempts available to the student. Specify 0 to set unlimited recording attempts.
+    max_recording_attempts: Optional[int] = None
+    # The title of the speaker progress resource visible to students.
+    presentation_title: Optional[str] = None
+    # The time limit is in minutes for the student recording.
+    recording_time_limit_in_minutes: Optional[int] = None
+    # Allows students to view their rehearsal report before the assignment is graded.
+    show_rehearsal_report_to_student_before_media_upload: Optional[bool] = None
+    # The feedback types that students should receive from the Speaker Coach.
+    speaker_coach_settings: Optional[EducationSpeakerCoachSettings] = None
+    # The spoken language for the student recording. For example, en-US.
+    spoken_language_locale: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> EducationSpeakerProgressResource:
+        """
+        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: EducationSpeakerProgressResource
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return EducationSpeakerProgressResource()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .education_ai_feedback_criteria import EducationAiFeedbackCriteria
+        from .education_resource import EducationResource
+        from .education_speaker_coach_settings import EducationSpeakerCoachSettings
+
+        from .education_ai_feedback_criteria import EducationAiFeedbackCriteria
+        from .education_resource import EducationResource
+        from .education_speaker_coach_settings import EducationSpeakerCoachSettings
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "aiFeedbackCriteria": lambda n : setattr(self, 'ai_feedback_criteria', n.get_object_value(EducationAiFeedbackCriteria)),
+            "isAiFeedbackEnabled": lambda n : setattr(self, 'is_ai_feedback_enabled', n.get_bool_value()),
+            "isVideoRequired": lambda n : setattr(self, 'is_video_required', n.get_bool_value()),
+            "maxRecordingAttempts": lambda n : setattr(self, 'max_recording_attempts', n.get_int_value()),
+            "presentationTitle": lambda n : setattr(self, 'presentation_title', n.get_str_value()),
+            "recordingTimeLimitInMinutes": lambda n : setattr(self, 'recording_time_limit_in_minutes', n.get_int_value()),
+            "showRehearsalReportToStudentBeforeMediaUpload": lambda n : setattr(self, 'show_rehearsal_report_to_student_before_media_upload', n.get_bool_value()),
+            "speakerCoachSettings": lambda n : setattr(self, 'speaker_coach_settings', n.get_object_value(EducationSpeakerCoachSettings)),
+            "spokenLanguageLocale": lambda n : setattr(self, 'spoken_language_locale', n.get_str_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_object_value("aiFeedbackCriteria", self.ai_feedback_criteria)
+        writer.write_bool_value("isAiFeedbackEnabled", self.is_ai_feedback_enabled)
+        writer.write_bool_value("isVideoRequired", self.is_video_required)
+        writer.write_int_value("maxRecordingAttempts", self.max_recording_attempts)
+        writer.write_str_value("presentationTitle", self.presentation_title)
+        writer.write_int_value("recordingTimeLimitInMinutes", self.recording_time_limit_in_minutes)
+        writer.write_bool_value("showRehearsalReportToStudentBeforeMediaUpload", self.show_rehearsal_report_to_student_before_media_upload)
+        writer.write_object_value("speakerCoachSettings", self.speaker_coach_settings)
+        writer.write_str_value("spokenLanguageLocale", self.spoken_language_locale)
+    
+

msgraph/generated/models/education_speech_type.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class EducationSpeechType(str, Enum):
+    Informative = "informative",
+    Personal = "personal",
+    Persuasive = "persuasive",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/education_submission_resource.py

@@ -12,8 +12,10 @@ from .entity import Entity
 
 @dataclass
 class EducationSubmissionResource(Entity, Parsable):
-    # Pointer to the assignment from which the resource was copied, and if null, the student uploaded the resource.
+    # Pointer to the assignment from which the resource was copied. If the value is null, the student uploaded the resource.
     assignment_resource_url: Optional[str] = None
+    # A collection of submission resources that depend on the parent educationSubmissionResource.
+    dependent_resources: Optional[list[EducationSubmissionResource]] = None
     # The OdataType property
     odata_type: Optional[str] = None
     # Resource object.
@@ -43,6 +45,7 @@ class EducationSubmissionResource(Entity, Parsable):
 
         fields: dict[str, Callable[[Any], None]] = {
             "assignmentResourceUrl": lambda n : setattr(self, 'assignment_resource_url', n.get_str_value()),
+            "dependentResources": lambda n : setattr(self, 'dependent_resources', n.get_collection_of_object_values(EducationSubmissionResource)),
             "resource": lambda n : setattr(self, 'resource', n.get_object_value(EducationResource)),
         }
         super_fields = super().get_field_deserializers()
@@ -59,6 +62,7 @@ class EducationSubmissionResource(Entity, Parsable):
             raise TypeError("writer cannot be null.")
         super().serialize(writer)
         writer.write_str_value("assignmentResourceUrl", self.assignment_resource_url)
+        writer.write_collection_of_object_values("dependentResources", self.dependent_resources)
         writer.write_object_value("resource", self.resource)
     
 

msgraph/generated/models/emergency_call_event.py

@@ -12,13 +12,13 @@ from .call_event import CallEvent
 
 @dataclass
 class EmergencyCallEvent(CallEvent, Parsable):
-    # The callerInfo property
+    # The information of the emergency caller.
     caller_info: Optional[EmergencyCallerInfo] = None
-    # The emergencyNumberDialed property
+    # The emergency number dialed.
     emergency_number_dialed: Optional[str] = None
     # The OdataType property
     odata_type: Optional[str] = None
-    # The policyName property
+    # The policy name for the emergency call event.
     policy_name: Optional[str] = None
     
     @staticmethod

msgraph/generated/models/emergency_caller_info.py

@@ -15,17 +15,17 @@ class EmergencyCallerInfo(AdditionalDataHolder, BackedModel, Parsable):
 
     # 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 displayName property
+    # The display name of the emergency caller.
     display_name: Optional[str] = None
-    # The location property
+    # The location of the emergency caller.
     location: Optional[Location] = None
     # The OdataType property
     odata_type: Optional[str] = None
-    # The phoneNumber property
+    # The phone number of the emergency caller.
     phone_number: Optional[str] = None
-    # The tenantId property
+    # The tenant ID of the emergency caller.
     tenant_id: Optional[str] = None
-    # The upn property
+    # The user principal name of the emergency caller.
     upn: Optional[str] = None
     
     @staticmethod

msgraph/generated/models/engagement_conversation.py

@@ -0,0 +1,90 @@
+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 .engagement_conversation_message import EngagementConversationMessage
+    from .engagement_creation_mode import EngagementCreationMode
+    from .entity import Entity
+    from .online_meeting_engagement_conversation import OnlineMeetingEngagementConversation
+
+from .entity import Entity
+
+@dataclass
+class EngagementConversation(Entity, Parsable):
+    """
+    Represents a conversation in Viva Engage.
+    """
+    # Indicates that the resource is in migration state and is currently being used for migration purposes.
+    creation_mode: Optional[EngagementCreationMode] = None
+    # The messages in a Viva Engage conversation.
+    messages: Optional[list[EngagementConversationMessage]] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The starter property
+    starter: Optional[EngagementConversationMessage] = None
+    # The unique ID of the first message in a Viva Engage conversation.
+    starter_id: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> EngagementConversation:
+        """
+        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: EngagementConversation
+        """
+        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.onlineMeetingEngagementConversation".casefold():
+            from .online_meeting_engagement_conversation import OnlineMeetingEngagementConversation
+
+            return OnlineMeetingEngagementConversation()
+        return EngagementConversation()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .engagement_conversation_message import EngagementConversationMessage
+        from .engagement_creation_mode import EngagementCreationMode
+        from .entity import Entity
+        from .online_meeting_engagement_conversation import OnlineMeetingEngagementConversation
+
+        from .engagement_conversation_message import EngagementConversationMessage
+        from .engagement_creation_mode import EngagementCreationMode
+        from .entity import Entity
+        from .online_meeting_engagement_conversation import OnlineMeetingEngagementConversation
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "creationMode": lambda n : setattr(self, 'creation_mode', n.get_enum_value(EngagementCreationMode)),
+            "messages": lambda n : setattr(self, 'messages', n.get_collection_of_object_values(EngagementConversationMessage)),
+            "starter": lambda n : setattr(self, 'starter', n.get_object_value(EngagementConversationMessage)),
+            "starterId": lambda n : setattr(self, 'starter_id', n.get_str_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_enum_value("creationMode", self.creation_mode)
+        writer.write_collection_of_object_values("messages", self.messages)
+        writer.write_object_value("starter", self.starter)
+        writer.write_str_value("starterId", self.starter_id)
+    
+

msgraph/generated/models/engagement_conversation_discussion_message.py

@@ -0,0 +1,56 @@
+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 .engagement_conversation_message import EngagementConversationMessage
+
+from .engagement_conversation_message import EngagementConversationMessage
+
+@dataclass
+class EngagementConversationDiscussionMessage(EngagementConversationMessage, Parsable):
+    """
+    A Viva Engage conversation discussion message.
+    """
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.engagementConversationDiscussionMessage"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> EngagementConversationDiscussionMessage:
+        """
+        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: EngagementConversationDiscussionMessage
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return EngagementConversationDiscussionMessage()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .engagement_conversation_message import EngagementConversationMessage
+
+        from .engagement_conversation_message import EngagementConversationMessage
+
+        fields: dict[str, Callable[[Any], None]] = {
+        }
+        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)
+    
+

msgraph/generated/models/engagement_conversation_message.py

@@ -0,0 +1,136 @@
+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 .engagement_conversation import EngagementConversation
+    from .engagement_conversation_discussion_message import EngagementConversationDiscussionMessage
+    from .engagement_conversation_message_reaction import EngagementConversationMessageReaction
+    from .engagement_conversation_question_message import EngagementConversationQuestionMessage
+    from .engagement_conversation_system_message import EngagementConversationSystemMessage
+    from .engagement_creation_mode import EngagementCreationMode
+    from .engagement_identity_set import EngagementIdentitySet
+    from .entity import Entity
+    from .item_body import ItemBody
+
+from .entity import Entity
+
+@dataclass
+class EngagementConversationMessage(Entity, Parsable):
+    """
+    A Viva Engage conversation message.
+    """
+    # The body property
+    body: Optional[ItemBody] = None
+    # The conversation property
+    conversation: Optional[EngagementConversation] = None
+    # The date and time when the message was created. The timestamp type represents date and time information using ISO 8601 format and is always in UTC. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z.
+    created_date_time: Optional[datetime.datetime] = None
+    # Indicates that the resource is in migration state and is currently being used for migration purposes.
+    creation_mode: Optional[EngagementCreationMode] = None
+    # Identity of the sender of the message.
+    from_: Optional[EngagementIdentitySet] = None
+    # The date and time when message was last modified. The timestamp type represents date and time information using ISO 8601 format and is always in UTC. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z.
+    last_modified_date_time: Optional[datetime.datetime] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # A collection of reactions (such as like and smile) that users have applied to this message.
+    reactions: Optional[list[EngagementConversationMessageReaction]] = None
+    # A collection of messages that are replies to this message and form a threaded discussion.
+    replies: Optional[list[EngagementConversationMessage]] = None
+    # The parent message to which this message is a reply, if it is part of a reply chain.
+    reply_to: Optional[EngagementConversationMessage] = None
+    # The ID of the parent message to which this message is a reply, if applicable.
+    reply_to_id: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> EngagementConversationMessage:
+        """
+        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: EngagementConversationMessage
+        """
+        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.engagementConversationDiscussionMessage".casefold():
+            from .engagement_conversation_discussion_message import EngagementConversationDiscussionMessage
+
+            return EngagementConversationDiscussionMessage()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.engagementConversationQuestionMessage".casefold():
+            from .engagement_conversation_question_message import EngagementConversationQuestionMessage
+
+            return EngagementConversationQuestionMessage()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.engagementConversationSystemMessage".casefold():
+            from .engagement_conversation_system_message import EngagementConversationSystemMessage
+
+            return EngagementConversationSystemMessage()
+        return EngagementConversationMessage()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .engagement_conversation import EngagementConversation
+        from .engagement_conversation_discussion_message import EngagementConversationDiscussionMessage
+        from .engagement_conversation_message_reaction import EngagementConversationMessageReaction
+        from .engagement_conversation_question_message import EngagementConversationQuestionMessage
+        from .engagement_conversation_system_message import EngagementConversationSystemMessage
+        from .engagement_creation_mode import EngagementCreationMode
+        from .engagement_identity_set import EngagementIdentitySet
+        from .entity import Entity
+        from .item_body import ItemBody
+
+        from .engagement_conversation import EngagementConversation
+        from .engagement_conversation_discussion_message import EngagementConversationDiscussionMessage
+        from .engagement_conversation_message_reaction import EngagementConversationMessageReaction
+        from .engagement_conversation_question_message import EngagementConversationQuestionMessage
+        from .engagement_conversation_system_message import EngagementConversationSystemMessage
+        from .engagement_creation_mode import EngagementCreationMode
+        from .engagement_identity_set import EngagementIdentitySet
+        from .entity import Entity
+        from .item_body import ItemBody
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "body": lambda n : setattr(self, 'body', n.get_object_value(ItemBody)),
+            "conversation": lambda n : setattr(self, 'conversation', n.get_object_value(EngagementConversation)),
+            "createdDateTime": lambda n : setattr(self, 'created_date_time', n.get_datetime_value()),
+            "creationMode": lambda n : setattr(self, 'creation_mode', n.get_enum_value(EngagementCreationMode)),
+            "from": lambda n : setattr(self, 'from_', n.get_object_value(EngagementIdentitySet)),
+            "lastModifiedDateTime": lambda n : setattr(self, 'last_modified_date_time', n.get_datetime_value()),
+            "reactions": lambda n : setattr(self, 'reactions', n.get_collection_of_object_values(EngagementConversationMessageReaction)),
+            "replies": lambda n : setattr(self, 'replies', n.get_collection_of_object_values(EngagementConversationMessage)),
+            "replyTo": lambda n : setattr(self, 'reply_to', n.get_object_value(EngagementConversationMessage)),
+            "replyToId": lambda n : setattr(self, 'reply_to_id', n.get_str_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_object_value("body", self.body)
+        writer.write_object_value("conversation", self.conversation)
+        writer.write_enum_value("creationMode", self.creation_mode)
+        writer.write_object_value("from", self.from_)
+        writer.write_collection_of_object_values("reactions", self.reactions)
+        writer.write_collection_of_object_values("replies", self.replies)
+        writer.write_object_value("replyTo", self.reply_to)
+        writer.write_str_value("replyToId", self.reply_to_id)
+    
+

msgraph/generated/models/{telecom_expense_management_partner_collection_response.py → engagement_conversation_message_collection_response.py}

@@ -6,25 +6,25 @@ from typing import Any, Optional, TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
     from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
-    from .telecom_expense_management_partner import TelecomExpenseManagementPartner
+    from .engagement_conversation_message import EngagementConversationMessage
 
 from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
 
 @dataclass
-class TelecomExpenseManagementPartnerCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+class EngagementConversationMessageCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
     # The value property
-    value: Optional[list[TelecomExpenseManagementPartner]] = None
+    value: Optional[list[EngagementConversationMessage]] = None
     
     @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> TelecomExpenseManagementPartnerCollectionResponse:
+    def create_from_discriminator_value(parse_node: ParseNode) -> EngagementConversationMessageCollectionResponse:
         """
         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: TelecomExpenseManagementPartnerCollectionResponse
+        Returns: EngagementConversationMessageCollectionResponse
         """
         if parse_node is None:
             raise TypeError("parse_node cannot be null.")
-        return TelecomExpenseManagementPartnerCollectionResponse()
+        return EngagementConversationMessageCollectionResponse()
     
     def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
         """
@@ -32,13 +32,13 @@ class TelecomExpenseManagementPartnerCollectionResponse(BaseCollectionPagination
         Returns: dict[str, Callable[[ParseNode], None]]
         """
         from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
-        from .telecom_expense_management_partner import TelecomExpenseManagementPartner
+        from .engagement_conversation_message import EngagementConversationMessage
 
         from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
-        from .telecom_expense_management_partner import TelecomExpenseManagementPartner
+        from .engagement_conversation_message import EngagementConversationMessage
 
         fields: dict[str, Callable[[Any], None]] = {
-            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(TelecomExpenseManagementPartner)),
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(EngagementConversationMessage)),
         }
         super_fields = super().get_field_deserializers()
         fields.update(super_fields)

msgraph/generated/models/engagement_conversation_message_reaction.py

@@ -0,0 +1,74 @@
+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 .engagement_conversation_message_reaction_type import EngagementConversationMessageReactionType
+    from .engagement_identity_set import EngagementIdentitySet
+    from .entity import Entity
+
+from .entity import Entity
+
+@dataclass
+class EngagementConversationMessageReaction(Entity, Parsable):
+    """
+    A reaction to a conversation message.
+    """
+    # Date and time when the reaction was added. The timestamp type represents date and time information using ISO 8601 format and is always in UTC. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z.
+    created_date_time: Optional[datetime.datetime] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The reactionBy property
+    reaction_by: Optional[EngagementIdentitySet] = None
+    # Types of reactions to conversation messages.
+    reaction_type: Optional[EngagementConversationMessageReactionType] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> EngagementConversationMessageReaction:
+        """
+        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: EngagementConversationMessageReaction
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return EngagementConversationMessageReaction()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .engagement_conversation_message_reaction_type import EngagementConversationMessageReactionType
+        from .engagement_identity_set import EngagementIdentitySet
+        from .entity import Entity
+
+        from .engagement_conversation_message_reaction_type import EngagementConversationMessageReactionType
+        from .engagement_identity_set import EngagementIdentitySet
+        from .entity import Entity
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "createdDateTime": lambda n : setattr(self, 'created_date_time', n.get_datetime_value()),
+            "reactionBy": lambda n : setattr(self, 'reaction_by', n.get_object_value(EngagementIdentitySet)),
+            "reactionType": lambda n : setattr(self, 'reaction_type', n.get_enum_value(EngagementConversationMessageReactionType)),
+        }
+        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_object_value("reactionBy", self.reaction_by)
+        writer.write_enum_value("reactionType", self.reaction_type)
+    
+

msgraph/generated/models/engagement_conversation_message_reaction_collection_response.py

@@ -0,0 +1,58 @@
+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 .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+    from .engagement_conversation_message_reaction import EngagementConversationMessageReaction
+
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+
+@dataclass
+class EngagementConversationMessageReactionCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[list[EngagementConversationMessageReaction]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> EngagementConversationMessageReactionCollectionResponse:
+        """
+        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: EngagementConversationMessageReactionCollectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return EngagementConversationMessageReactionCollectionResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .engagement_conversation_message_reaction import EngagementConversationMessageReaction
+
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .engagement_conversation_message_reaction import EngagementConversationMessageReaction
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(EngagementConversationMessageReaction)),
+        }
+        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("value", self.value)
+    
+