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

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/audit_log_record_collection_response.py → reflect_check_in_response_collection_response.py}

@@ -5,40 +5,40 @@ from kiota_abstractions.serialization import Parsable, ParseNode, SerializationW
 from typing import Any, Optional, TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
-    from ..base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
-    from .audit_log_record import AuditLogRecord
+    from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+    from .reflect_check_in_response import ReflectCheckInResponse
 
-from ..base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
 
 @dataclass
-class AuditLogRecordCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+class ReflectCheckInResponseCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
     # The value property
-    value: Optional[list[AuditLogRecord]] = None
+    value: Optional[list[ReflectCheckInResponse]] = None
     
     @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> AuditLogRecordCollectionResponse:
+    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: AuditLogRecordCollectionResponse
+        Returns: ReflectCheckInResponseCollectionResponse
         """
         if parse_node is None:
             raise TypeError("parse_node cannot be null.")
-        return AuditLogRecordCollectionResponse()
+        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 ..base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
-        from .audit_log_record import AuditLogRecord
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .reflect_check_in_response import ReflectCheckInResponse
 
-        from ..base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
-        from .audit_log_record import AuditLogRecord
+        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(AuditLogRecord)),
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(ReflectCheckInResponse)),
         }
         super_fields = super().get_field_deserializers()
         fields.update(super_fields)

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/security/ediscovery_add_to_review_set_operation.py

@@ -17,13 +17,13 @@ from .case_operation import CaseOperation
 
 @dataclass
 class EdiscoveryAddToReviewSetOperation(CaseOperation, Parsable):
-    # The additionalDataOptions property
+    # The options to add items to the review set. Possible values are: allVersions, linkedFiles, unknownFutureValue, advancedIndexing, listAttachments, htmlTranscripts, messageConversationExpansion, locationsWithoutHits, allItemsInFolder. Use the Prefer: include-unknown-enum-members request header to get the following values from this evolvable enum: advancedIndexing, listAttachments, htmlTranscripts, messageConversationExpansion, locationsWithoutHits, allItemsInFolder.
     additional_data_options: Optional[AdditionalDataOptions] = None
-    # The cloudAttachmentVersion property
+    # Specifies the number of most recent versions of cloud attachments to collect. Possible values are: latest, recent10, recent100, all, unknownFutureValue.
     cloud_attachment_version: Optional[CloudAttachmentVersion] = None
-    # The documentVersion property
+    # Specifies the number of most recent versions of SharePoint documents to collect. Possible values are: latest, recent10, recent100, all, unknownFutureValue.
     document_version: Optional[DocumentVersion] = None
-    # The itemsToInclude property
+    # The items to include in the review set. Possible values are: searchHits, partiallyIndexed, unknownFutureValue.
     items_to_include: Optional[ItemsToInclude] = None
     # The OdataType property
     odata_type: Optional[str] = None

msgraph/generated/models/security/ediscovery_estimate_operation.py

@@ -25,7 +25,7 @@ class EdiscoveryEstimateOperation(CaseOperation, Parsable):
     search: Optional[EdiscoverySearch] = None
     # The number of mailboxes that had search hits.
     site_count: Optional[int] = None
-    # The statisticsOptions property
+    # The options to generate statistics. Possible values are: includeRefiners, includeQueryStats, includeUnindexedStats, advancedIndexing, locationsWithoutHits, unknownFutureValue.
     statistics_options: Optional[StatisticsOptions] = None
     # The estimated count of unindexed items for the collection.
     unindexed_item_count: Optional[int] = None

msgraph/generated/models/security/ediscovery_export_operation.py

@@ -20,9 +20,9 @@ class EdiscoveryExportOperation(CaseOperation, Parsable):
     description: Optional[str] = None
     # Contains the properties for an export file metadata, including downloadUrl, fileName, and size.
     export_file_metadata: Optional[list[ExportFileMetadata]] = None
-    # The options provided for the export. For more information, see reviewSet: export. Possible values are: originalFiles, text, pdfReplacement,  tags.
+    # The options provided for the export. For more information, see reviewSet: export. Possible values are: originalFiles, text, pdfReplacement, tags, unknownFutureValue, splitSource, includeFolderAndPath, friendlyName, condensePaths. Use the Prefer: include-unknown-enum-members request header to get the following values from this evolvable enum: splitSource, includeFolderAndPath, friendlyName, condensePaths.
     export_options: Optional[ExportOptions] = None
-    # The options that specify the structure of the export. For more information, see reviewSet: export. Possible values are: none, directory, pst.
+    # The options that specify the structure of the export. For more information, see reviewSet: export. Possible values are: none, directory (deprecated), pst, unknownFutureValue, msg. Use the Prefer: include-unknown-enum-members request header to get the following value from this evolvable enum: msg. The directory member is deprecated. It remains in v1.0 for backward compatibility. Going forward, use either pst or msg.
     export_structure: Optional[ExportFileStructure] = None
     # The OdataType property
     odata_type: Optional[str] = None

msgraph/generated/models/security/ediscovery_search_export_operation.py

@@ -19,21 +19,21 @@ from .case_operation import CaseOperation
 
 @dataclass
 class EdiscoverySearchExportOperation(CaseOperation, Parsable):
-    # The additional items to include in the export. The possible values are: none, teamsAndYammerConversations, cloudAttachments, allDocumentVersions, subfolderContents, listAttachments, unknownFutureValue.
+    # The additional items to include in the export. The possible values are: none, teamsAndYammerConversations, cloudAttachments, allDocumentVersions, subfolderContents, listAttachments, unknownFutureValue, htmlTranscripts, advancedIndexing, allItemsInFolder, includeFolderAndPath, condensePaths, friendlyName, splitSource, includeReport. Use the Prefer: include-unknown-enum-members request header to get the following values from this evolvable enum: htmlTranscripts, advancedIndexing, allItemsInFolder, includeFolderAndPath, condensePaths, friendlyName, splitSource, includeReport.
     additional_options: Optional[AdditionalOptions] = None
-    # The cloudAttachmentVersion property
+    # The versions of cloud attachments to include in messages. Possible values are: latest, recent10, recent100, all, unknownFutureValue.
     cloud_attachment_version: Optional[CloudAttachmentVersion] = None
     # The description of the export by the user.
     description: Optional[str] = None
     # The name of export provided by the user.
     display_name: Optional[str] = None
-    # The documentVersion property
+    # The versions of files in SharePoint to include. Possible values are: latest, recent10, recent100, all, unknownFutureValue.
     document_version: Optional[DocumentVersion] = None
     # Items to be included in the export. The possible values are: searchHits, partiallyIndexed, unknownFutureValue.
     export_criteria: Optional[ExportCriteria] = None
     # Contains the properties for an export file metadata, including downloadUrl, fileName, and size.
     export_file_metadata: Optional[list[ExportFileMetadata]] = None
-    # Format of the emails of the export. The possible values are: pst, msg, eml, unknownFutureValue.
+    # Format of the emails of the export. The possible values are: pst, msg, eml (deprecated), unknownFutureValue. The eml member is deprecated. It remains in v1.0 for backward compatibility. Going forward, use either pst or msg.
     export_format: Optional[ExportFormat] = None
     # Location scope for partially indexed items. You can choose to include partially indexed items only in responsive locations with search hits or in all targeted locations. The possible values are: responsiveLocations, nonresponsiveLocations, unknownFutureValue.
     export_location: Optional[ExportLocation] = None

msgraph/generated/models/security/security.py

@@ -13,7 +13,6 @@ if TYPE_CHECKING:
     from ..subject_rights_request import SubjectRightsRequest
     from ..tenant_data_security_and_governance import TenantDataSecurityAndGovernance
     from .alert import Alert
-    from .audit_core_root import AuditCoreRoot
     from .cases_root import CasesRoot
     from .identity_container import IdentityContainer
     from .incident import Incident
@@ -32,8 +31,6 @@ class Security(Entity, Parsable):
     alerts_v2: Optional[list[Alert]] = None
     # The attackSimulation property
     attack_simulation: Optional[AttackSimulationRoot] = None
-    # The auditLog property
-    audit_log: Optional[AuditCoreRoot] = None
     # The cases property
     cases: Optional[CasesRoot] = None
     # The dataSecurityAndGovernance property
@@ -83,7 +80,6 @@ class Security(Entity, Parsable):
         from ..subject_rights_request import SubjectRightsRequest
         from ..tenant_data_security_and_governance import TenantDataSecurityAndGovernance
         from .alert import Alert
-        from .audit_core_root import AuditCoreRoot
         from .cases_root import CasesRoot
         from .identity_container import IdentityContainer
         from .incident import Incident
@@ -100,7 +96,6 @@ class Security(Entity, Parsable):
         from ..subject_rights_request import SubjectRightsRequest
         from ..tenant_data_security_and_governance import TenantDataSecurityAndGovernance
         from .alert import Alert
-        from .audit_core_root import AuditCoreRoot
         from .cases_root import CasesRoot
         from .identity_container import IdentityContainer
         from .incident import Incident
@@ -113,7 +108,6 @@ class Security(Entity, Parsable):
             "alerts": lambda n : setattr(self, 'alerts', n.get_collection_of_object_values(Alert)),
             "alerts_v2": lambda n : setattr(self, 'alerts_v2', n.get_collection_of_object_values(Alert)),
             "attackSimulation": lambda n : setattr(self, 'attack_simulation', n.get_object_value(AttackSimulationRoot)),
-            "auditLog": lambda n : setattr(self, 'audit_log', n.get_object_value(AuditCoreRoot)),
             "cases": lambda n : setattr(self, 'cases', n.get_object_value(CasesRoot)),
             "dataSecurityAndGovernance": lambda n : setattr(self, 'data_security_and_governance', n.get_object_value(TenantDataSecurityAndGovernance)),
             "identities": lambda n : setattr(self, 'identities', n.get_object_value(IdentityContainer)),
@@ -142,7 +136,6 @@ class Security(Entity, Parsable):
         writer.write_collection_of_object_values("alerts", self.alerts)
         writer.write_collection_of_object_values("alerts_v2", self.alerts_v2)
         writer.write_object_value("attackSimulation", self.attack_simulation)
-        writer.write_object_value("auditLog", self.audit_log)
         writer.write_object_value("cases", self.cases)
         writer.write_object_value("dataSecurityAndGovernance", self.data_security_and_governance)
         writer.write_object_value("identities", self.identities)

msgraph/generated/models/{security/mail_submission_data.py → service_principal_sign_in.py}

@@ -5,36 +5,39 @@ 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 .sign_in_identity import SignInIdentity
 
-from .audit_data import AuditData
+from .sign_in_identity import SignInIdentity
 
 @dataclass
-class MailSubmissionData(AuditData, Parsable):
+class ServicePrincipalSignIn(SignInIdentity, Parsable):
     # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.mailSubmissionData"
+    odata_type: Optional[str] = "#microsoft.graph.servicePrincipalSignIn"
+    # appId of the service principal that is signing in.
+    service_principal_id: Optional[str] = None
     
     @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> MailSubmissionData:
+    def create_from_discriminator_value(parse_node: ParseNode) -> ServicePrincipalSignIn:
         """
         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: MailSubmissionData
+        Returns: ServicePrincipalSignIn
         """
         if parse_node is None:
             raise TypeError("parse_node cannot be null.")
-        return MailSubmissionData()
+        return ServicePrincipalSignIn()
     
     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 .sign_in_identity import SignInIdentity
 
-        from .audit_data import AuditData
+        from .sign_in_identity import SignInIdentity
 
         fields: dict[str, Callable[[Any], None]] = {
+            "servicePrincipalId": lambda n : setattr(self, 'service_principal_id', n.get_str_value()),
         }
         super_fields = super().get_field_deserializers()
         fields.update(super_fields)
@@ -49,5 +52,6 @@ class MailSubmissionData(AuditData, Parsable):
         if writer is None:
             raise TypeError("writer cannot be null.")
         super().serialize(writer)
+        writer.write_str_value("servicePrincipalId", self.service_principal_id)
     
 

msgraph/generated/models/shift_activity.py

@@ -20,13 +20,13 @@ class ShiftActivity(AdditionalDataHolder, BackedModel, Parsable):
     code: Optional[str] = None
     # The name of the shiftActivity. Required.
     display_name: Optional[str] = None
-    # The end date and time for the shiftActivity. 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. Required.
+    # The end date and time for the shiftActivity. The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z. Required.
     end_date_time: Optional[datetime.datetime] = None
     # Indicates whether the microsoft.graph.user should be paid for the activity during their shift. Required.
     is_paid: Optional[bool] = None
     # The OdataType property
     odata_type: Optional[str] = None
-    # The start date and time for the shiftActivity. 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. Required.
+    # The start date and time for the shiftActivity. The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z. Required.
     start_date_time: Optional[datetime.datetime] = None
     # The theme property
     theme: Optional[ScheduleEntityTheme] = None

msgraph/generated/models/sign_in_conditions.py

@@ -0,0 +1,112 @@
+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 .authentication_flow import AuthenticationFlow
+    from .conditional_access_client_app import ConditionalAccessClientApp
+    from .conditional_access_device_platform import ConditionalAccessDevicePlatform
+    from .device_info import DeviceInfo
+    from .insider_risk_level import InsiderRiskLevel
+    from .risk_level import RiskLevel
+
+@dataclass
+class SignInConditions(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)
+    # Type of authentication flow. The possible value is: deviceCodeFlow or authenticationTransfer. Default value is none.
+    authentication_flow: Optional[AuthenticationFlow] = None
+    # Client application type. The possible value is: all, browser, mobileAppsAndDesktopClients, exchangeActiveSync, easSupported, other, unknownFutureValue. Default value is all.
+    client_app_type: Optional[ConditionalAccessClientApp] = None
+    # Country from where the identity is authenticating.
+    country: Optional[str] = None
+    # Information about the device used for the sign-in.
+    device_info: Optional[DeviceInfo] = None
+    # Device platform. The possible value is: android, iOS, windows, windowsPhone, macOS, all, unknownFutureValue, linux. Default value is all.
+    device_platform: Optional[ConditionalAccessDevicePlatform] = None
+    # Insider risk associated with the authenticating user. The possible value is: none, minor, moderate, elevated, unknownFutureValue. Default value is none.
+    insider_risk_level: Optional[InsiderRiskLevel] = None
+    # Ip address of the authenticating identity.
+    ip_address: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # Risk associated with the service principal. The possible value is: low, medium, high, hidden, none, unknownFutureValue. Default value is none.
+    service_principal_risk_level: Optional[RiskLevel] = None
+    # Sign-in risk associated with the user. The possible value is: low, medium, high, hidden, none, unknownFutureValue. Default value is none.
+    sign_in_risk_level: Optional[RiskLevel] = None
+    # The authenticating user's risk level. The possible value is: low, medium, high, hidden, none, unknownFutureValue. Default value is none.
+    user_risk_level: Optional[RiskLevel] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SignInConditions:
+        """
+        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: SignInConditions
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SignInConditions()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .authentication_flow import AuthenticationFlow
+        from .conditional_access_client_app import ConditionalAccessClientApp
+        from .conditional_access_device_platform import ConditionalAccessDevicePlatform
+        from .device_info import DeviceInfo
+        from .insider_risk_level import InsiderRiskLevel
+        from .risk_level import RiskLevel
+
+        from .authentication_flow import AuthenticationFlow
+        from .conditional_access_client_app import ConditionalAccessClientApp
+        from .conditional_access_device_platform import ConditionalAccessDevicePlatform
+        from .device_info import DeviceInfo
+        from .insider_risk_level import InsiderRiskLevel
+        from .risk_level import RiskLevel
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "authenticationFlow": lambda n : setattr(self, 'authentication_flow', n.get_object_value(AuthenticationFlow)),
+            "clientAppType": lambda n : setattr(self, 'client_app_type', n.get_enum_value(ConditionalAccessClientApp)),
+            "country": lambda n : setattr(self, 'country', n.get_str_value()),
+            "deviceInfo": lambda n : setattr(self, 'device_info', n.get_object_value(DeviceInfo)),
+            "devicePlatform": lambda n : setattr(self, 'device_platform', n.get_enum_value(ConditionalAccessDevicePlatform)),
+            "insiderRiskLevel": lambda n : setattr(self, 'insider_risk_level', n.get_enum_value(InsiderRiskLevel)),
+            "ipAddress": lambda n : setattr(self, 'ip_address', n.get_str_value()),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "servicePrincipalRiskLevel": lambda n : setattr(self, 'service_principal_risk_level', n.get_enum_value(RiskLevel)),
+            "signInRiskLevel": lambda n : setattr(self, 'sign_in_risk_level', n.get_enum_value(RiskLevel)),
+            "userRiskLevel": lambda n : setattr(self, 'user_risk_level', n.get_enum_value(RiskLevel)),
+        }
+        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_object_value("authenticationFlow", self.authentication_flow)
+        writer.write_enum_value("clientAppType", self.client_app_type)
+        writer.write_str_value("country", self.country)
+        writer.write_object_value("deviceInfo", self.device_info)
+        writer.write_enum_value("devicePlatform", self.device_platform)
+        writer.write_enum_value("insiderRiskLevel", self.insider_risk_level)
+        writer.write_str_value("ipAddress", self.ip_address)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_enum_value("servicePrincipalRiskLevel", self.service_principal_risk_level)
+        writer.write_enum_value("signInRiskLevel", self.sign_in_risk_level)
+        writer.write_enum_value("userRiskLevel", self.user_risk_level)
+        writer.write_additional_data_value(self.additional_data)
+    
+