msgraph-sdk 1.39.0__py3-none-any.whl → 1.44.0__py3-none-any.whl

msgraph/generated/models/reading_assignment_submission.py

@@ -0,0 +1,141 @@
+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 .challenging_word import ChallengingWord
+    from .entity import Entity
+
+from .entity import Entity
+
+@dataclass
+class ReadingAssignmentSubmission(Entity, Parsable):
+    # Accuracy score of the reading progress.
+    accuracy_score: Optional[float] = None
+    # Indicates whether the submission is an attempt by the student or a miscue edit done by the educator. The possible values are Attempt and EditMiscue.
+    action: Optional[str] = None
+    # ID of the assignment with which this submission is associated.
+    assignment_id: Optional[str] = None
+    # List of words that the student found challenging during the reading session.
+    challenging_words: Optional[list[ChallengingWord]] = None
+    # ID of the class this reading progress is associated with.
+    class_id: Optional[str] = None
+    # Insertions of the reading progress.
+    insertions: Optional[int] = None
+    # Mispronunciations of the reading progress.
+    mispronunciations: Optional[int] = None
+    # Number of exclamation marks missed in the reading passage.
+    missed_exclamation_marks: Optional[int] = None
+    # Number of periods missed in the reading passage.
+    missed_periods: Optional[int] = None
+    # Number of question marks missed in the reading passage.
+    missed_question_marks: Optional[int] = None
+    # Number of short words missed during the reading session.
+    missed_shorts: Optional[int] = None
+    # Score that reflects the student's use of intonation and expression. Lower scores indicate more monotone reading.
+    monotone_score: Optional[float] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # Omissions of the reading progress.
+    omissions: Optional[int] = None
+    # Number of times the student repeated words or phrases during the reading session.
+    repetitions: Optional[int] = None
+    # Number of times the student self-corrected their reading errors.
+    self_corrections: Optional[int] = None
+    # ID of the user this reading progress is associated with.
+    student_id: Optional[str] = None
+    # Date and time of the submission this reading progress is associated with. 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.
+    submission_date_time: Optional[datetime.datetime] = None
+    # ID of the submission this reading progress is associated with.
+    submission_id: Optional[str] = None
+    # Number of unexpected pauses made during the reading session.
+    unexpected_pauses: Optional[int] = None
+    # Words count of the reading progress.
+    word_count: Optional[int] = None
+    # Words per minute of the reading progress.
+    words_per_minute: Optional[float] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ReadingAssignmentSubmission:
+        """
+        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: ReadingAssignmentSubmission
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ReadingAssignmentSubmission()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .challenging_word import ChallengingWord
+        from .entity import Entity
+
+        from .challenging_word import ChallengingWord
+        from .entity import Entity
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "accuracyScore": lambda n : setattr(self, 'accuracy_score', n.get_float_value()),
+            "action": lambda n : setattr(self, 'action', n.get_str_value()),
+            "assignmentId": lambda n : setattr(self, 'assignment_id', n.get_str_value()),
+            "challengingWords": lambda n : setattr(self, 'challenging_words', n.get_collection_of_object_values(ChallengingWord)),
+            "classId": lambda n : setattr(self, 'class_id', n.get_str_value()),
+            "insertions": lambda n : setattr(self, 'insertions', n.get_int_value()),
+            "mispronunciations": lambda n : setattr(self, 'mispronunciations', n.get_int_value()),
+            "missedExclamationMarks": lambda n : setattr(self, 'missed_exclamation_marks', n.get_int_value()),
+            "missedPeriods": lambda n : setattr(self, 'missed_periods', n.get_int_value()),
+            "missedQuestionMarks": lambda n : setattr(self, 'missed_question_marks', n.get_int_value()),
+            "missedShorts": lambda n : setattr(self, 'missed_shorts', n.get_int_value()),
+            "monotoneScore": lambda n : setattr(self, 'monotone_score', n.get_float_value()),
+            "omissions": lambda n : setattr(self, 'omissions', n.get_int_value()),
+            "repetitions": lambda n : setattr(self, 'repetitions', n.get_int_value()),
+            "selfCorrections": lambda n : setattr(self, 'self_corrections', n.get_int_value()),
+            "studentId": lambda n : setattr(self, 'student_id', n.get_str_value()),
+            "submissionDateTime": lambda n : setattr(self, 'submission_date_time', n.get_datetime_value()),
+            "submissionId": lambda n : setattr(self, 'submission_id', n.get_str_value()),
+            "unexpectedPauses": lambda n : setattr(self, 'unexpected_pauses', n.get_int_value()),
+            "wordCount": lambda n : setattr(self, 'word_count', n.get_int_value()),
+            "wordsPerMinute": lambda n : setattr(self, 'words_per_minute', n.get_float_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_float_value("accuracyScore", self.accuracy_score)
+        writer.write_str_value("action", self.action)
+        writer.write_str_value("assignmentId", self.assignment_id)
+        writer.write_collection_of_object_values("challengingWords", self.challenging_words)
+        writer.write_str_value("classId", self.class_id)
+        writer.write_int_value("insertions", self.insertions)
+        writer.write_int_value("mispronunciations", self.mispronunciations)
+        writer.write_int_value("missedExclamationMarks", self.missed_exclamation_marks)
+        writer.write_int_value("missedPeriods", self.missed_periods)
+        writer.write_int_value("missedQuestionMarks", self.missed_question_marks)
+        writer.write_int_value("missedShorts", self.missed_shorts)
+        writer.write_float_value("monotoneScore", self.monotone_score)
+        writer.write_int_value("omissions", self.omissions)
+        writer.write_int_value("repetitions", self.repetitions)
+        writer.write_int_value("selfCorrections", self.self_corrections)
+        writer.write_str_value("studentId", self.student_id)
+        writer.write_datetime_value("submissionDateTime", self.submission_date_time)
+        writer.write_str_value("submissionId", self.submission_id)
+        writer.write_int_value("unexpectedPauses", self.unexpected_pauses)
+        writer.write_int_value("wordCount", self.word_count)
+        writer.write_float_value("wordsPerMinute", self.words_per_minute)
+    
+

msgraph/generated/models/reading_assignment_submission_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 .reading_assignment_submission import ReadingAssignmentSubmission
+
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+
+@dataclass
+class ReadingAssignmentSubmissionCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[list[ReadingAssignmentSubmission]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ReadingAssignmentSubmissionCollectionResponse:
+        """
+        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: ReadingAssignmentSubmissionCollectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ReadingAssignmentSubmissionCollectionResponse()
+    
+    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 .reading_assignment_submission import ReadingAssignmentSubmission
+
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .reading_assignment_submission import ReadingAssignmentSubmission
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(ReadingAssignmentSubmission)),
+        }
+        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)
+    
+

msgraph/generated/models/reflect_check_in_response.py

@@ -0,0 +1,100 @@
+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 .entity import Entity
+    from .response_emotion_type import ResponseEmotionType
+    from .response_feedback_type import ResponseFeedbackType
+
+from .entity import Entity
+
+@dataclass
+class ReflectCheckInResponse(Entity, Parsable):
+    # Identifier for the Reflect check-in.
+    check_in_id: Optional[str] = None
+    # The question or prompt of the Reflect check-in that this response addresses.
+    check_in_title: Optional[str] = None
+    # ID of the class associated with the Reflect check-in.
+    class_id: Optional[str] = None
+    # Date and time when the Reflect check-in 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
+    # ID of the user who created the Reflect check-in.
+    creator_id: Optional[str] = None
+    # Indicates whether the Reflect check-in is closed (true) or open (false).
+    is_closed: Optional[bool] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # ID of the user who responded to the Reflect check-in.
+    responder_id: Optional[str] = None
+    # The responseEmotion property
+    response_emotion: Optional[ResponseEmotionType] = None
+    # The responseFeedback property
+    response_feedback: Optional[ResponseFeedbackType] = None
+    # Date and time when the response to the Reflect check-in was submitted. 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.
+    submit_date_time: Optional[datetime.datetime] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ReflectCheckInResponse:
+        """
+        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: ReflectCheckInResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ReflectCheckInResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .entity import Entity
+        from .response_emotion_type import ResponseEmotionType
+        from .response_feedback_type import ResponseFeedbackType
+
+        from .entity import Entity
+        from .response_emotion_type import ResponseEmotionType
+        from .response_feedback_type import ResponseFeedbackType
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "checkInId": lambda n : setattr(self, 'check_in_id', n.get_str_value()),
+            "checkInTitle": lambda n : setattr(self, 'check_in_title', n.get_str_value()),
+            "classId": lambda n : setattr(self, 'class_id', n.get_str_value()),
+            "createdDateTime": lambda n : setattr(self, 'created_date_time', n.get_datetime_value()),
+            "creatorId": lambda n : setattr(self, 'creator_id', n.get_str_value()),
+            "isClosed": lambda n : setattr(self, 'is_closed', n.get_bool_value()),
+            "responderId": lambda n : setattr(self, 'responder_id', n.get_str_value()),
+            "responseEmotion": lambda n : setattr(self, 'response_emotion', n.get_enum_value(ResponseEmotionType)),
+            "responseFeedback": lambda n : setattr(self, 'response_feedback', n.get_enum_value(ResponseFeedbackType)),
+            "submitDateTime": lambda n : setattr(self, 'submit_date_time', n.get_datetime_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_str_value("checkInId", self.check_in_id)
+        writer.write_str_value("checkInTitle", self.check_in_title)
+        writer.write_str_value("classId", self.class_id)
+        writer.write_datetime_value("createdDateTime", self.created_date_time)
+        writer.write_str_value("creatorId", self.creator_id)
+        writer.write_bool_value("isClosed", self.is_closed)
+        writer.write_str_value("responderId", self.responder_id)
+        writer.write_enum_value("responseEmotion", self.response_emotion)
+        writer.write_enum_value("responseFeedback", self.response_feedback)
+        writer.write_datetime_value("submitDateTime", self.submit_date_time)
+    
+

msgraph/generated/models/{security/aip_file_deleted.py → reflect_check_in_response_collection_response.py}

@@ -5,36 +5,40 @@ from kiota_abstractions.serialization import Parsable, ParseNode, SerializationW
 from typing import Any, Optional, TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
-    from .audit_data import AuditData
+    from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+    from .reflect_check_in_response import ReflectCheckInResponse
 
-from .audit_data import AuditData
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
 
 @dataclass
-class AipFileDeleted(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.aipFileDeleted"
+class ReflectCheckInResponseCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[list[ReflectCheckInResponse]] = None
     
     @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> AipFileDeleted:
+    def create_from_discriminator_value(parse_node: ParseNode) -> ReflectCheckInResponseCollectionResponse:
         """
         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: AipFileDeleted
+        Returns: ReflectCheckInResponseCollectionResponse
         """
         if parse_node is None:
             raise TypeError("parse_node cannot be null.")
-        return AipFileDeleted()
+        return ReflectCheckInResponseCollectionResponse()
     
     def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
         """
         The deserialization information for the current model
         Returns: dict[str, Callable[[ParseNode], None]]
         """
-        from .audit_data import AuditData
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .reflect_check_in_response import ReflectCheckInResponse
 
-        from .audit_data import AuditData
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .reflect_check_in_response import ReflectCheckInResponse
 
         fields: dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(ReflectCheckInResponse)),
         }
         super_fields = super().get_field_deserializers()
         fields.update(super_fields)
@@ -49,5 +53,6 @@ class AipFileDeleted(AuditData, Parsable):
         if writer is None:
             raise TypeError("writer cannot be null.")
         super().serialize(writer)
+        writer.write_collection_of_object_values("value", self.value)
     
 

msgraph/generated/models/{security/audit_core_root.py → reports_root.py}

@@ -5,42 +5,48 @@ from kiota_abstractions.serialization import Parsable, ParseNode, SerializationW
 from typing import Any, Optional, TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
-    from ..entity import Entity
-    from .audit_log_query import AuditLogQuery
+    from .entity import Entity
+    from .reading_assignment_submission import ReadingAssignmentSubmission
+    from .reflect_check_in_response import ReflectCheckInResponse
 
-from ..entity import Entity
+from .entity import Entity
 
 @dataclass
-class AuditCoreRoot(Entity, Parsable):
+class ReportsRoot(Entity, Parsable):
     # The OdataType property
     odata_type: Optional[str] = None
-    # The queries property
-    queries: Optional[list[AuditLogQuery]] = None
+    # The readingAssignmentSubmissions property
+    reading_assignment_submissions: Optional[list[ReadingAssignmentSubmission]] = None
+    # The reflectCheckInResponses property
+    reflect_check_in_responses: Optional[list[ReflectCheckInResponse]] = None
     
     @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> AuditCoreRoot:
+    def create_from_discriminator_value(parse_node: ParseNode) -> ReportsRoot:
         """
         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: AuditCoreRoot
+        Returns: ReportsRoot
         """
         if parse_node is None:
             raise TypeError("parse_node cannot be null.")
-        return AuditCoreRoot()
+        return ReportsRoot()
     
     def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
         """
         The deserialization information for the current model
         Returns: dict[str, Callable[[ParseNode], None]]
         """
-        from ..entity import Entity
-        from .audit_log_query import AuditLogQuery
+        from .entity import Entity
+        from .reading_assignment_submission import ReadingAssignmentSubmission
+        from .reflect_check_in_response import ReflectCheckInResponse
 
-        from ..entity import Entity
-        from .audit_log_query import AuditLogQuery
+        from .entity import Entity
+        from .reading_assignment_submission import ReadingAssignmentSubmission
+        from .reflect_check_in_response import ReflectCheckInResponse
 
         fields: dict[str, Callable[[Any], None]] = {
-            "queries": lambda n : setattr(self, 'queries', n.get_collection_of_object_values(AuditLogQuery)),
+            "readingAssignmentSubmissions": lambda n : setattr(self, 'reading_assignment_submissions', n.get_collection_of_object_values(ReadingAssignmentSubmission)),
+            "reflectCheckInResponses": lambda n : setattr(self, 'reflect_check_in_responses', n.get_collection_of_object_values(ReflectCheckInResponse)),
         }
         super_fields = super().get_field_deserializers()
         fields.update(super_fields)
@@ -55,6 +61,7 @@ class AuditCoreRoot(Entity, Parsable):
         if writer is None:
             raise TypeError("writer cannot be null.")
         super().serialize(writer)
-        writer.write_collection_of_object_values("queries", self.queries)
+        writer.write_collection_of_object_values("readingAssignmentSubmissions", self.reading_assignment_submissions)
+        writer.write_collection_of_object_values("reflectCheckInResponses", self.reflect_check_in_responses)
     
 

msgraph/generated/models/response_emotion_type.py

@@ -0,0 +1,62 @@
+from enum import Enum
+
+class ResponseEmotionType(str, Enum):
+    None_ = "none",
+    Confident = "confident",
+    Excited = "excited",
+    Happy = "happy",
+    Motivated = "motivated",
+    Peaceful = "peaceful",
+    Ambitious = "ambitious",
+    Cheerful = "cheerful",
+    Comfortable = "comfortable",
+    Creative = "creative",
+    Determined = "determined",
+    Energized = "energized",
+    Focused = "focused",
+    Fulfilled = "fulfilled",
+    Grateful = "grateful",
+    Included = "included",
+    Inspired = "inspired",
+    Optimistic = "optimistic",
+    Proud = "proud",
+    Successful = "successful",
+    Valuable = "valuable",
+    Annoyed = "annoyed",
+    Bored = "bored",
+    Calm = "calm",
+    Confused = "confused",
+    Glad = "glad",
+    Content = "content",
+    Pensive = "pensive",
+    Reserved = "reserved",
+    Restless = "restless",
+    Shocked = "shocked",
+    Tired = "tired",
+    Angry = "angry",
+    Depressed = "depressed",
+    Exhausted = "exhausted",
+    Lonely = "lonely",
+    Nervous = "nervous",
+    Anxious = "anxious",
+    Apathetic = "apathetic",
+    Concerned = "concerned",
+    Disappointed = "disappointed",
+    Frightened = "frightened",
+    Frustrated = "frustrated",
+    Hopeless = "hopeless",
+    Hurt = "hurt",
+    Jealous = "jealous",
+    Miserable = "miserable",
+    Overwhelmed = "overwhelmed",
+    Skeptical = "skeptical",
+    Stressed = "stressed",
+    Stuck = "stuck",
+    Worthless = "worthless",
+    Awed = "awed",
+    Ashamed = "ashamed",
+    Curious = "curious",
+    Sensitive = "sensitive",
+    Sad = "sad",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/response_feedback_type.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+class ResponseFeedbackType(str, Enum):
+    None_ = "none",
+    NotDetected = "notDetected",
+    VeryUnpleasant = "veryUnpleasant",
+    Unpleasant = "unpleasant",
+    Neutral = "neutral",
+    Pleasant = "pleasant",
+    VeryPleasant = "veryPleasant",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/restore_job_type.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class RestoreJobType(str, Enum):
+    Standard = "standard",
+    Bulk = "bulk",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/restore_session_artifact_count.py

@@ -0,0 +1,66 @@
+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 RestoreSessionArtifactCount(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 number of artifacts whose restoration completed.
+    completed: Optional[int] = None
+    # The number of artifacts whose restoration failed.
+    failed: Optional[int] = None
+    # The number of artifacts whose restoration is in progress.
+    in_progress: Optional[int] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The number of artifacts present in the restore session.
+    total: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> RestoreSessionArtifactCount:
+        """
+        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: RestoreSessionArtifactCount
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return RestoreSessionArtifactCount()
+    
+    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]] = {
+            "completed": lambda n : setattr(self, 'completed', n.get_int_value()),
+            "failed": lambda n : setattr(self, 'failed', n.get_int_value()),
+            "inProgress": lambda n : setattr(self, 'in_progress', n.get_int_value()),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "total": lambda n : setattr(self, 'total', n.get_int_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_int_value("completed", self.completed)
+        writer.write_int_value("failed", self.failed)
+        writer.write_int_value("inProgress", self.in_progress)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_int_value("total", self.total)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/restore_session_base.py

@@ -11,6 +11,8 @@ if TYPE_CHECKING:
     from .identity_set import IdentitySet
     from .one_drive_for_business_restore_session import OneDriveForBusinessRestoreSession
     from .public_error import PublicError
+    from .restore_job_type import RestoreJobType
+    from .restore_session_artifact_count import RestoreSessionArtifactCount
     from .restore_session_status import RestoreSessionStatus
     from .share_point_restore_session import SharePointRestoreSession
 
@@ -32,6 +34,10 @@ class RestoreSessionBase(Entity, Parsable):
     last_modified_date_time: Optional[datetime.datetime] = None
     # The OdataType property
     odata_type: Optional[str] = None
+    # Indicates whether the restore session was created normally or by a bulk job.
+    restore_job_type: Optional[RestoreJobType] = None
+    # The number of metadata artifacts that belong to this restore session.
+    restore_session_artifact_count: Optional[RestoreSessionArtifactCount] = None
     # Status of the restore session. The value is an aggregated status of the restored artifacts. The possible values are: draft, activating, active, completedWithError, completed, unknownFutureValue, failed. Use the Prefer: include-unknown-enum-members request header to get the following value in this evolvable enum: failed.
     status: Optional[RestoreSessionStatus] = None
     
@@ -73,6 +79,8 @@ class RestoreSessionBase(Entity, Parsable):
         from .identity_set import IdentitySet
         from .one_drive_for_business_restore_session import OneDriveForBusinessRestoreSession
         from .public_error import PublicError
+        from .restore_job_type import RestoreJobType
+        from .restore_session_artifact_count import RestoreSessionArtifactCount
         from .restore_session_status import RestoreSessionStatus
         from .share_point_restore_session import SharePointRestoreSession
 
@@ -81,6 +89,8 @@ class RestoreSessionBase(Entity, Parsable):
         from .identity_set import IdentitySet
         from .one_drive_for_business_restore_session import OneDriveForBusinessRestoreSession
         from .public_error import PublicError
+        from .restore_job_type import RestoreJobType
+        from .restore_session_artifact_count import RestoreSessionArtifactCount
         from .restore_session_status import RestoreSessionStatus
         from .share_point_restore_session import SharePointRestoreSession
 
@@ -91,6 +101,8 @@ class RestoreSessionBase(Entity, Parsable):
             "error": lambda n : setattr(self, 'error', n.get_object_value(PublicError)),
             "lastModifiedBy": lambda n : setattr(self, 'last_modified_by', n.get_object_value(IdentitySet)),
             "lastModifiedDateTime": lambda n : setattr(self, 'last_modified_date_time', n.get_datetime_value()),
+            "restoreJobType": lambda n : setattr(self, 'restore_job_type', n.get_enum_value(RestoreJobType)),
+            "restoreSessionArtifactCount": lambda n : setattr(self, 'restore_session_artifact_count', n.get_object_value(RestoreSessionArtifactCount)),
             "status": lambda n : setattr(self, 'status', n.get_enum_value(RestoreSessionStatus)),
         }
         super_fields = super().get_field_deserializers()
@@ -112,6 +124,8 @@ class RestoreSessionBase(Entity, Parsable):
         writer.write_object_value("error", self.error)
         writer.write_object_value("lastModifiedBy", self.last_modified_by)
         writer.write_datetime_value("lastModifiedDateTime", self.last_modified_date_time)
+        writer.write_enum_value("restoreJobType", self.restore_job_type)
+        writer.write_object_value("restoreSessionArtifactCount", self.restore_session_artifact_count)
         writer.write_enum_value("status", self.status)
     
 

msgraph/generated/models/security/alert.py

@@ -43,7 +43,7 @@ class Alert(Entity, Parsable):
     custom_details: Optional[Dictionary] = None
     # String value describing each alert.
     description: Optional[str] = None
-    # Detection technology or sensor that identified the notable component or activity. Possible values are: unknown, microsoftDefenderForEndpoint, antivirus, smartScreen, customTi, microsoftDefenderForOffice365, automatedInvestigation, microsoftThreatExperts, customDetection, microsoftDefenderForIdentity, cloudAppSecurity, microsoft365Defender, azureAdIdentityProtection, manual, microsoftDataLossPrevention, appGovernancePolicy, appGovernanceDetection, unknownFutureValue, microsoftDefenderForCloud, microsoftDefenderForIoT, microsoftDefenderForServers, microsoftDefenderForStorage, microsoftDefenderForDNS, microsoftDefenderForDatabases, microsoftDefenderForContainers, microsoftDefenderForNetwork, microsoftDefenderForAppService, microsoftDefenderForKeyVault, microsoftDefenderForResourceManager, microsoftDefenderForApiManagement, microsoftSentinel, nrtAlerts, scheduledAlerts, microsoftDefenderThreatIntelligenceAnalytics, builtInMl, microsoftThreatIntelligence. Use the Prefer: include-unknown-enum-members request header to get the following values in this evolvable enum: microsoftDefenderForCloud, microsoftDefenderForIoT, microsoftDefenderForServers, microsoftDefenderForStorage, microsoftDefenderForDNS, microsoftDefenderForDatabases, microsoftDefenderForContainers, microsoftDefenderForNetwork, microsoftDefenderForAppService, microsoftDefenderForKeyVault, microsoftDefenderForResourceManager, microsoftDefenderForApiManagement, microsoftSentinel, nrtAlerts, scheduledAlerts, microsoftDefenderThreatIntelligenceAnalytics, builtInMl, microsoftThreatIntelligence.
+    # Detection technology or sensor that identified the notable component or activity. Possible values are: unknown, microsoftDefenderForEndpoint, antivirus, smartScreen, customTi, microsoftDefenderForOffice365, automatedInvestigation, microsoftThreatExperts, customDetection, microsoftDefenderForIdentity, cloudAppSecurity, microsoft365Defender, azureAdIdentityProtection, manual, microsoftDataLossPrevention, appGovernancePolicy, appGovernanceDetection, unknownFutureValue, microsoftDefenderForCloud, microsoftDefenderForIoT, microsoftDefenderForServers, microsoftDefenderForStorage, microsoftDefenderForDNS, microsoftDefenderForDatabases, microsoftDefenderForContainers, microsoftDefenderForNetwork, microsoftDefenderForAppService, microsoftDefenderForKeyVault, microsoftDefenderForResourceManager, microsoftDefenderForApiManagement, microsoftSentinel, nrtAlerts, scheduledAlerts, microsoftDefenderThreatIntelligenceAnalytics, builtInMl, microsoftThreatIntelligence, microsoftDefenderForAIServices, securityCopilot. Use the Prefer: include-unknown-enum-members request header to get the following values in this evolvable enum: microsoftDefenderForCloud, microsoftDefenderForIoT, microsoftDefenderForServers, microsoftDefenderForStorage, microsoftDefenderForDNS, microsoftDefenderForDatabases, microsoftDefenderForContainers, microsoftDefenderForNetwork, microsoftDefenderForAppService, microsoftDefenderForKeyVault, microsoftDefenderForResourceManager, microsoftDefenderForApiManagement, microsoftSentinel, nrtAlerts, scheduledAlerts, microsoftDefenderThreatIntelligenceAnalytics, builtInMl, microsoftThreatIntelligence, microsoftDefenderForAIServices, securityCopilot.
     detection_source: Optional[DetectionSource] = None
     # The ID of the detector that triggered the alert.
     detector_id: Optional[str] = None