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

msgraph/generated/kiota-lock.json

@@ -1,5 +1,5 @@
 {
-  "descriptionHash": "F66F35AF42DFD96FE735D23A13B33683547FA331442A856BCC89322EB087DAA1BB96F0AF787D4DA6C09602408DE805BDAC8EAD927DB56D532AC2A62171CF5CDF",
+  "descriptionHash": "223D71ECA0A4C835A62B531C2D6BA7C1FF2CC4F1835150F3C212C92291D612C004B42290D6D95549E15CCCE072305EEFC724D43D63E5A25B3FE6C5C8D8F4449D",
   "descriptionLocation": "../../msgraph-metadata/clean_v10_openapi/openapi.yaml",
   "lockFileVersion": "1.0.0",
   "kiotaVersion": "1.29.0",

msgraph/generated/models/{security/project_for_the_web_project_settings_audit_record.py → application_context.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_context import SignInContext
 
-from .audit_data import AuditData
+from .sign_in_context import SignInContext
 
 @dataclass
-class ProjectForTheWebProjectSettingsAuditRecord(AuditData, Parsable):
+class ApplicationContext(SignInContext, Parsable):
     # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.projectForTheWebProjectSettingsAuditRecord"
+    odata_type: Optional[str] = "#microsoft.graph.applicationContext"
+    # Collection of appId values for the applications.
+    include_applications: Optional[list[str]] = None
     
     @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> ProjectForTheWebProjectSettingsAuditRecord:
+    def create_from_discriminator_value(parse_node: ParseNode) -> ApplicationContext:
         """
         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: ProjectForTheWebProjectSettingsAuditRecord
+        Returns: ApplicationContext
         """
         if parse_node is None:
             raise TypeError("parse_node cannot be null.")
-        return ProjectForTheWebProjectSettingsAuditRecord()
+        return ApplicationContext()
     
     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_context import SignInContext
 
-        from .audit_data import AuditData
+        from .sign_in_context import SignInContext
 
         fields: dict[str, Callable[[Any], None]] = {
+            "includeApplications": lambda n : setattr(self, 'include_applications', n.get_collection_of_primitive_values(str)),
         }
         super_fields = super().get_field_deserializers()
         fields.update(super_fields)
@@ -49,5 +52,6 @@ class ProjectForTheWebProjectSettingsAuditRecord(AuditData, Parsable):
         if writer is None:
             raise TypeError("writer cannot be null.")
         super().serialize(writer)
+        writer.write_collection_of_primitive_values("includeApplications", self.include_applications)
     
 

msgraph/generated/models/{security/aad_risk_detection_audit_record.py → auth_context.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_context import SignInContext
 
-from .audit_data import AuditData
+from .sign_in_context import SignInContext
 
 @dataclass
-class AadRiskDetectionAuditRecord(AuditData, Parsable):
+class AuthContext(SignInContext, Parsable):
     # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.aadRiskDetectionAuditRecord"
+    odata_type: Optional[str] = "#microsoft.graph.authContext"
+    # Supported values are c1 through c99.
+    authentication_context_value: Optional[str] = None
     
     @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> AadRiskDetectionAuditRecord:
+    def create_from_discriminator_value(parse_node: ParseNode) -> AuthContext:
         """
         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: AadRiskDetectionAuditRecord
+        Returns: AuthContext
         """
         if parse_node is None:
             raise TypeError("parse_node cannot be null.")
-        return AadRiskDetectionAuditRecord()
+        return AuthContext()
     
     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_context import SignInContext
 
-        from .audit_data import AuditData
+        from .sign_in_context import SignInContext
 
         fields: dict[str, Callable[[Any], None]] = {
+            "authenticationContextValue": lambda n : setattr(self, 'authentication_context_value', n.get_str_value()),
         }
         super_fields = super().get_field_deserializers()
         fields.update(super_fields)
@@ -49,5 +52,6 @@ class AadRiskDetectionAuditRecord(AuditData, Parsable):
         if writer is None:
             raise TypeError("writer cannot be null.")
         super().serialize(writer)
+        writer.write_str_value("authenticationContextValue", self.authentication_context_value)
     
 

msgraph/generated/models/authentication_flow.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from kiota_abstractions.store import BackedModel, BackingStore, BackingStoreFactorySingleton
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .conditional_access_transfer_methods import ConditionalAccessTransferMethods
+
+@dataclass
+class AuthenticationFlow(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 OdataType property
+    odata_type: Optional[str] = None
+    # Represents the transfer methods in scope for the policy. The possible values are: none, deviceCodeFlow, authenticationTransfer, unknownFutureValue. Default value is none.
+    transfer_method: Optional[ConditionalAccessTransferMethods] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AuthenticationFlow:
+        """
+        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: AuthenticationFlow
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AuthenticationFlow()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .conditional_access_transfer_methods import ConditionalAccessTransferMethods
+
+        from .conditional_access_transfer_methods import ConditionalAccessTransferMethods
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "transferMethod": lambda n : setattr(self, 'transfer_method', n.get_collection_of_enum_values(ConditionalAccessTransferMethods)),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_enum_value("transferMethod", self.transfer_method)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/challenging_word.py

@@ -0,0 +1,58 @@
+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 ChallengingWord(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)
+    # Number of times the word was found challenging by the student during the reading session.
+    count: Optional[int] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The specific word that the student found challenging during the reading session.
+    word: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ChallengingWord:
+        """
+        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: ChallengingWord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ChallengingWord()
+    
+    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]] = {
+            "count": lambda n : setattr(self, 'count', n.get_int_value()),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "word": lambda n : setattr(self, 'word', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_int_value("count", self.count)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_str_value("word", self.word)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/conditional_access_policy.py

@@ -11,6 +11,7 @@ if TYPE_CHECKING:
     from .conditional_access_policy_state import ConditionalAccessPolicyState
     from .conditional_access_session_controls import ConditionalAccessSessionControls
     from .entity import Entity
+    from .what_if_analysis_result import WhatIfAnalysisResult
 
 from .entity import Entity
 
@@ -34,7 +35,7 @@ class ConditionalAccessPolicy(Entity, Parsable):
     session_controls: Optional[ConditionalAccessSessionControls] = None
     # The state property
     state: Optional[ConditionalAccessPolicyState] = None
-    # The templateId property
+    # Specifies the unique identifier of a Conditional Access template. Inherited from entity.
     template_id: Optional[str] = None
     
     @staticmethod
@@ -46,6 +47,15 @@ class ConditionalAccessPolicy(Entity, Parsable):
         """
         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.whatIfAnalysisResult".casefold():
+            from .what_if_analysis_result import WhatIfAnalysisResult
+
+            return WhatIfAnalysisResult()
         return ConditionalAccessPolicy()
     
     def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
@@ -58,12 +68,14 @@ class ConditionalAccessPolicy(Entity, Parsable):
         from .conditional_access_policy_state import ConditionalAccessPolicyState
         from .conditional_access_session_controls import ConditionalAccessSessionControls
         from .entity import Entity
+        from .what_if_analysis_result import WhatIfAnalysisResult
 
         from .conditional_access_condition_set import ConditionalAccessConditionSet
         from .conditional_access_grant_controls import ConditionalAccessGrantControls
         from .conditional_access_policy_state import ConditionalAccessPolicyState
         from .conditional_access_session_controls import ConditionalAccessSessionControls
         from .entity import Entity
+        from .what_if_analysis_result import WhatIfAnalysisResult
 
         fields: dict[str, Callable[[Any], None]] = {
             "conditions": lambda n : setattr(self, 'conditions', n.get_object_value(ConditionalAccessConditionSet)),

msgraph/generated/models/conversation_member.py

@@ -11,6 +11,7 @@ if TYPE_CHECKING:
     from .azure_communication_services_user_conversation_member import AzureCommunicationServicesUserConversationMember
     from .entity import Entity
     from .microsoft_account_user_conversation_member import MicrosoftAccountUserConversationMember
+    from .phone_user_conversation_member import PhoneUserConversationMember
     from .skype_for_business_user_conversation_member import SkypeForBusinessUserConversationMember
     from .skype_user_conversation_member import SkypeUserConversationMember
 
@@ -57,6 +58,10 @@ class ConversationMember(Entity, Parsable):
             from .microsoft_account_user_conversation_member import MicrosoftAccountUserConversationMember
 
             return MicrosoftAccountUserConversationMember()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.phoneUserConversationMember".casefold():
+            from .phone_user_conversation_member import PhoneUserConversationMember
+
+            return PhoneUserConversationMember()
         if mapping_value and mapping_value.casefold() == "#microsoft.graph.skypeForBusinessUserConversationMember".casefold():
             from .skype_for_business_user_conversation_member import SkypeForBusinessUserConversationMember
 
@@ -77,6 +82,7 @@ class ConversationMember(Entity, Parsable):
         from .azure_communication_services_user_conversation_member import AzureCommunicationServicesUserConversationMember
         from .entity import Entity
         from .microsoft_account_user_conversation_member import MicrosoftAccountUserConversationMember
+        from .phone_user_conversation_member import PhoneUserConversationMember
         from .skype_for_business_user_conversation_member import SkypeForBusinessUserConversationMember
         from .skype_user_conversation_member import SkypeUserConversationMember
 
@@ -85,6 +91,7 @@ class ConversationMember(Entity, Parsable):
         from .azure_communication_services_user_conversation_member import AzureCommunicationServicesUserConversationMember
         from .entity import Entity
         from .microsoft_account_user_conversation_member import MicrosoftAccountUserConversationMember
+        from .phone_user_conversation_member import PhoneUserConversationMember
         from .skype_for_business_user_conversation_member import SkypeForBusinessUserConversationMember
         from .skype_user_conversation_member import SkypeUserConversationMember
 

msgraph/generated/models/device_info.py

@@ -0,0 +1,166 @@
+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 DeviceInfo(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)
+    # Unique identifier set by Azure Device Registration Service at the time of registration.
+    device_id: Optional[str] = None
+    # The display name for the device.
+    display_name: Optional[str] = None
+    # Enrollment profile applied to the device.
+    enrollment_profile_name: Optional[str] = None
+    # Extension attribute.
+    extension_attribute1: Optional[str] = None
+    # Extension attribute.
+    extension_attribute10: Optional[str] = None
+    # Extension attribute.
+    extension_attribute11: Optional[str] = None
+    # Extension attribute.
+    extension_attribute12: Optional[str] = None
+    # Extension attribute.
+    extension_attribute13: Optional[str] = None
+    # Extension attribute.
+    extension_attribute14: Optional[str] = None
+    # Extension attribute.
+    extension_attribute15: Optional[str] = None
+    # Extension attribute.
+    extension_attribute2: Optional[str] = None
+    # Extension attribute.
+    extension_attribute3: Optional[str] = None
+    # Extension attribute.
+    extension_attribute4: Optional[str] = None
+    # Extension attribute.
+    extension_attribute5: Optional[str] = None
+    # Extension attribute.
+    extension_attribute6: Optional[str] = None
+    # Extension attribute.
+    extension_attribute7: Optional[str] = None
+    # Extension attribute.
+    extension_attribute8: Optional[str] = None
+    # Extension attribute.
+    extension_attribute9: Optional[str] = None
+    # Indicates the device compliance status with Mobile Management Device (MDM) policies. Default is false.
+    is_compliant: Optional[bool] = None
+    # Manufacturer of the device.
+    manufacturer: Optional[str] = None
+    # Application identifier used to register device into MDM.
+    mdm_app_id: Optional[str] = None
+    # Model of the device.
+    model: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The type of operating system on the device.
+    operating_system: Optional[str] = None
+    # The version of the operating system on the device.
+    operating_system_version: Optional[str] = None
+    # Ownership of the device. This property is set by Intune.
+    ownership: Optional[str] = None
+    # A collection of physical identifiers for the device.
+    physical_ids: Optional[list[str]] = None
+    # The profile type of the device.
+    profile_type: Optional[str] = None
+    # List of labels applied to the device by the system.
+    system_labels: Optional[list[str]] = None
+    # Type of trust for the joined device.
+    trust_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> DeviceInfo:
+        """
+        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: DeviceInfo
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return DeviceInfo()
+    
+    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]] = {
+            "deviceId": lambda n : setattr(self, 'device_id', n.get_str_value()),
+            "displayName": lambda n : setattr(self, 'display_name', n.get_str_value()),
+            "enrollmentProfileName": lambda n : setattr(self, 'enrollment_profile_name', n.get_str_value()),
+            "extensionAttribute1": lambda n : setattr(self, 'extension_attribute1', n.get_str_value()),
+            "extensionAttribute10": lambda n : setattr(self, 'extension_attribute10', n.get_str_value()),
+            "extensionAttribute11": lambda n : setattr(self, 'extension_attribute11', n.get_str_value()),
+            "extensionAttribute12": lambda n : setattr(self, 'extension_attribute12', n.get_str_value()),
+            "extensionAttribute13": lambda n : setattr(self, 'extension_attribute13', n.get_str_value()),
+            "extensionAttribute14": lambda n : setattr(self, 'extension_attribute14', n.get_str_value()),
+            "extensionAttribute15": lambda n : setattr(self, 'extension_attribute15', n.get_str_value()),
+            "extensionAttribute2": lambda n : setattr(self, 'extension_attribute2', n.get_str_value()),
+            "extensionAttribute3": lambda n : setattr(self, 'extension_attribute3', n.get_str_value()),
+            "extensionAttribute4": lambda n : setattr(self, 'extension_attribute4', n.get_str_value()),
+            "extensionAttribute5": lambda n : setattr(self, 'extension_attribute5', n.get_str_value()),
+            "extensionAttribute6": lambda n : setattr(self, 'extension_attribute6', n.get_str_value()),
+            "extensionAttribute7": lambda n : setattr(self, 'extension_attribute7', n.get_str_value()),
+            "extensionAttribute8": lambda n : setattr(self, 'extension_attribute8', n.get_str_value()),
+            "extensionAttribute9": lambda n : setattr(self, 'extension_attribute9', n.get_str_value()),
+            "isCompliant": lambda n : setattr(self, 'is_compliant', n.get_bool_value()),
+            "manufacturer": lambda n : setattr(self, 'manufacturer', n.get_str_value()),
+            "mdmAppId": lambda n : setattr(self, 'mdm_app_id', n.get_str_value()),
+            "model": lambda n : setattr(self, 'model', n.get_str_value()),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "operatingSystem": lambda n : setattr(self, 'operating_system', n.get_str_value()),
+            "operatingSystemVersion": lambda n : setattr(self, 'operating_system_version', n.get_str_value()),
+            "ownership": lambda n : setattr(self, 'ownership', n.get_str_value()),
+            "physicalIds": lambda n : setattr(self, 'physical_ids', n.get_collection_of_primitive_values(str)),
+            "profileType": lambda n : setattr(self, 'profile_type', n.get_str_value()),
+            "systemLabels": lambda n : setattr(self, 'system_labels', n.get_collection_of_primitive_values(str)),
+            "trustType": lambda n : setattr(self, 'trust_type', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("deviceId", self.device_id)
+        writer.write_str_value("displayName", self.display_name)
+        writer.write_str_value("enrollmentProfileName", self.enrollment_profile_name)
+        writer.write_str_value("extensionAttribute1", self.extension_attribute1)
+        writer.write_str_value("extensionAttribute10", self.extension_attribute10)
+        writer.write_str_value("extensionAttribute11", self.extension_attribute11)
+        writer.write_str_value("extensionAttribute12", self.extension_attribute12)
+        writer.write_str_value("extensionAttribute13", self.extension_attribute13)
+        writer.write_str_value("extensionAttribute14", self.extension_attribute14)
+        writer.write_str_value("extensionAttribute15", self.extension_attribute15)
+        writer.write_str_value("extensionAttribute2", self.extension_attribute2)
+        writer.write_str_value("extensionAttribute3", self.extension_attribute3)
+        writer.write_str_value("extensionAttribute4", self.extension_attribute4)
+        writer.write_str_value("extensionAttribute5", self.extension_attribute5)
+        writer.write_str_value("extensionAttribute6", self.extension_attribute6)
+        writer.write_str_value("extensionAttribute7", self.extension_attribute7)
+        writer.write_str_value("extensionAttribute8", self.extension_attribute8)
+        writer.write_str_value("extensionAttribute9", self.extension_attribute9)
+        writer.write_bool_value("isCompliant", self.is_compliant)
+        writer.write_str_value("manufacturer", self.manufacturer)
+        writer.write_str_value("mdmAppId", self.mdm_app_id)
+        writer.write_str_value("model", self.model)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_str_value("operatingSystem", self.operating_system)
+        writer.write_str_value("operatingSystemVersion", self.operating_system_version)
+        writer.write_str_value("ownership", self.ownership)
+        writer.write_collection_of_primitive_values("physicalIds", self.physical_ids)
+        writer.write_str_value("profileType", self.profile_type)
+        writer.write_collection_of_primitive_values("systemLabels", self.system_labels)
+        writer.write_str_value("trustType", self.trust_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/education_root.py

@@ -9,6 +9,7 @@ if TYPE_CHECKING:
     from .education_class import EducationClass
     from .education_school import EducationSchool
     from .education_user import EducationUser
+    from .reports_root import ReportsRoot
 
 @dataclass
 class EducationRoot(AdditionalDataHolder, BackedModel, Parsable):
@@ -23,6 +24,8 @@ class EducationRoot(AdditionalDataHolder, BackedModel, Parsable):
     me: Optional[EducationUser] = None
     # The OdataType property
     odata_type: Optional[str] = None
+    # The reports property
+    reports: Optional[ReportsRoot] = None
     # The schools property
     schools: Optional[list[EducationSchool]] = None
     # The users property
@@ -47,15 +50,18 @@ class EducationRoot(AdditionalDataHolder, BackedModel, Parsable):
         from .education_class import EducationClass
         from .education_school import EducationSchool
         from .education_user import EducationUser
+        from .reports_root import ReportsRoot
 
         from .education_class import EducationClass
         from .education_school import EducationSchool
         from .education_user import EducationUser
+        from .reports_root import ReportsRoot
 
         fields: dict[str, Callable[[Any], None]] = {
             "classes": lambda n : setattr(self, 'classes', n.get_collection_of_object_values(EducationClass)),
             "me": lambda n : setattr(self, 'me', n.get_object_value(EducationUser)),
             "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "reports": lambda n : setattr(self, 'reports', n.get_object_value(ReportsRoot)),
             "schools": lambda n : setattr(self, 'schools', n.get_collection_of_object_values(EducationSchool)),
             "users": lambda n : setattr(self, 'users', n.get_collection_of_object_values(EducationUser)),
         }
@@ -72,6 +78,7 @@ class EducationRoot(AdditionalDataHolder, BackedModel, Parsable):
         writer.write_collection_of_object_values("classes", self.classes)
         writer.write_object_value("me", self.me)
         writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_object_value("reports", self.reports)
         writer.write_collection_of_object_values("schools", self.schools)
         writer.write_collection_of_object_values("users", self.users)
         writer.write_additional_data_value(self.additional_data)