msgraph-sdk 1.49.0__py3-none-any.whl → 1.50.0__py3-none-any.whl

msgraph/generated/kiota-lock.json

@@ -1,5 +1,5 @@
 {
-  "descriptionHash": "D282F35F1C4502D8A194AC720C40CD42328A0D407D96EA32125D5E6F3F4483C6070BED2C504A5E1B5E49A4B1ABA6C9BEBA0FE6749B51318AC512B5FF4DD00ECC",
+  "descriptionHash": "B243F90AAC3F548EAA1D4BB9C012663E5F123A401E193B25D219B7D016381FF78B94701C2AF3F0DBDF12C8E8952F4095F9956FF17DE3320747B1A1BB91287751",
   "descriptionLocation": "../../msgraph-metadata/clean_v10_openapi/openapi.yaml",
   "lockFileVersion": "1.0.0",
   "kiotaVersion": "1.30.0",

msgraph/generated/models/assigned_place_mode.py

@@ -0,0 +1,61 @@
+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 .place_mode import PlaceMode
+
+from .place_mode import PlaceMode
+
+@dataclass
+class AssignedPlaceMode(PlaceMode, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.assignedPlaceMode"
+    # The assignedUserEmailAddress property
+    assigned_user_email_address: Optional[str] = None
+    # The assignedUserId property
+    assigned_user_id: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AssignedPlaceMode:
+        """
+        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: AssignedPlaceMode
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AssignedPlaceMode()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .place_mode import PlaceMode
+
+        from .place_mode import PlaceMode
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "assignedUserEmailAddress": lambda n : setattr(self, 'assigned_user_email_address', n.get_str_value()),
+            "assignedUserId": lambda n : setattr(self, 'assigned_user_id', n.get_str_value()),
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+        writer.write_str_value("assignedUserEmailAddress", self.assigned_user_email_address)
+        writer.write_str_value("assignedUserId", self.assigned_user_id)
+    
+

msgraph/generated/models/base_map_feature.py

@@ -0,0 +1,104 @@
+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 .building_map import BuildingMap
+    from .entity import Entity
+    from .fixture_map import FixtureMap
+    from .footprint_map import FootprintMap
+    from .level_map import LevelMap
+    from .section_map import SectionMap
+    from .unit_map import UnitMap
+
+from .entity import Entity
+
+@dataclass
+class BaseMapFeature(Entity, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The properties property
+    properties: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> BaseMapFeature:
+        """
+        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: BaseMapFeature
+        """
+        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.buildingMap".casefold():
+            from .building_map import BuildingMap
+
+            return BuildingMap()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.fixtureMap".casefold():
+            from .fixture_map import FixtureMap
+
+            return FixtureMap()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.footprintMap".casefold():
+            from .footprint_map import FootprintMap
+
+            return FootprintMap()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.levelMap".casefold():
+            from .level_map import LevelMap
+
+            return LevelMap()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.sectionMap".casefold():
+            from .section_map import SectionMap
+
+            return SectionMap()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.unitMap".casefold():
+            from .unit_map import UnitMap
+
+            return UnitMap()
+        return BaseMapFeature()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .building_map import BuildingMap
+        from .entity import Entity
+        from .fixture_map import FixtureMap
+        from .footprint_map import FootprintMap
+        from .level_map import LevelMap
+        from .section_map import SectionMap
+        from .unit_map import UnitMap
+
+        from .building_map import BuildingMap
+        from .entity import Entity
+        from .fixture_map import FixtureMap
+        from .footprint_map import FootprintMap
+        from .level_map import LevelMap
+        from .section_map import SectionMap
+        from .unit_map import UnitMap
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "properties": lambda n : setattr(self, 'properties', n.get_str_value()),
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+        writer.write_str_value("properties", self.properties)
+    
+

msgraph/generated/models/building.py

@@ -0,0 +1,67 @@
+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 .building_map import BuildingMap
+    from .place import Place
+    from .resource_link import ResourceLink
+
+from .place import Place
+
+@dataclass
+class Building(Place, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.building"
+    # The map property
+    map: Optional[BuildingMap] = None
+    # The resourceLinks property
+    resource_links: Optional[list[ResourceLink]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> Building:
+        """
+        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: Building
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return Building()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .building_map import BuildingMap
+        from .place import Place
+        from .resource_link import ResourceLink
+
+        from .building_map import BuildingMap
+        from .place import Place
+        from .resource_link import ResourceLink
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "map": lambda n : setattr(self, 'map', n.get_object_value(BuildingMap)),
+            "resourceLinks": lambda n : setattr(self, 'resource_links', n.get_collection_of_object_values(ResourceLink)),
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+        writer.write_object_value("map", self.map)
+        writer.write_collection_of_object_values("resourceLinks", self.resource_links)
+    
+

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

@@ -0,0 +1,71 @@
+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_map_feature import BaseMapFeature
+    from .footprint_map import FootprintMap
+    from .level_map import LevelMap
+
+from .base_map_feature import BaseMapFeature
+
+@dataclass
+class BuildingMap(BaseMapFeature, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.buildingMap"
+    # The footprints property
+    footprints: Optional[list[FootprintMap]] = None
+    # The levels property
+    levels: Optional[list[LevelMap]] = None
+    # The placeId property
+    place_id: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> BuildingMap:
+        """
+        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: BuildingMap
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return BuildingMap()
+    
+    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_map_feature import BaseMapFeature
+        from .footprint_map import FootprintMap
+        from .level_map import LevelMap
+
+        from .base_map_feature import BaseMapFeature
+        from .footprint_map import FootprintMap
+        from .level_map import LevelMap
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "footprints": lambda n : setattr(self, 'footprints', n.get_collection_of_object_values(FootprintMap)),
+            "levels": lambda n : setattr(self, 'levels', n.get_collection_of_object_values(LevelMap)),
+            "placeId": lambda n : setattr(self, 'place_id', n.get_str_value()),
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+        writer.write_collection_of_object_values("footprints", self.footprints)
+        writer.write_collection_of_object_values("levels", self.levels)
+        writer.write_str_value("placeId", self.place_id)
+    
+

msgraph/generated/models/channel.py

@@ -37,7 +37,7 @@ class Channel(Entity, Parsable):
     is_favorite_by_default: Optional[bool] = None
     # A collection of membership records associated with the channel.
     members: Optional[list[ConversationMember]] = None
-    # The type of the channel. Can be set during creation and can't be changed. The possible values are: standard, private, unknownFutureValue, shared. The default value is standard. Use the Prefer: include-unknown-enum-members request header to get the following value in this evolvable enum: shared.
+    # The type of the channel. Can be set during creation and can't be changed. The possible values are: standard, private, unknownFutureValue, shared. The default value is standard. Use the Prefer: include-unknown-enum-members request header to get the following members in this evolvable enum: shared.
     membership_type: Optional[ChannelMembershipType] = None
     # A collection of all the messages in the channel. A navigation property. Nullable.
     messages: Optional[list[ChatMessage]] = None

msgraph/generated/models/communications_guest_identity.py

@@ -13,6 +13,8 @@ from .identity import Identity
 class CommunicationsGuestIdentity(Identity, Parsable):
     # The OdataType property
     odata_type: Optional[str] = "#microsoft.graph.communicationsGuestIdentity"
+    # The email of the guest user.
+    email: Optional[str] = None
     
     @staticmethod
     def create_from_discriminator_value(parse_node: ParseNode) -> CommunicationsGuestIdentity:
@@ -35,6 +37,7 @@ class CommunicationsGuestIdentity(Identity, Parsable):
         from .identity import Identity
 
         fields: dict[str, Callable[[Any], None]] = {
+            "email": lambda n : setattr(self, 'email', n.get_str_value()),
         }
         super_fields = super().get_field_deserializers()
         fields.update(super_fields)
@@ -49,5 +52,6 @@ class CommunicationsGuestIdentity(Identity, Parsable):
         if writer is None:
             raise TypeError("writer cannot be null.")
         super().serialize(writer)
+        writer.write_str_value("email", self.email)
     
 

msgraph/generated/models/copilot_report_root.py

@@ -0,0 +1,53 @@
+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 .entity import Entity
+
+from .entity import Entity
+
+@dataclass
+class CopilotReportRoot(Entity, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> CopilotReportRoot:
+        """
+        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: CopilotReportRoot
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return CopilotReportRoot()
+    
+    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 .entity import Entity
+
+        fields: dict[str, Callable[[Any], None]] = {
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+    
+

msgraph/generated/models/desk.py

@@ -0,0 +1,71 @@
+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 .mailbox_details import MailboxDetails
+    from .place import Place
+    from .place_mode import PlaceMode
+
+from .place import Place
+
+@dataclass
+class Desk(Place, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.desk"
+    # The displayDeviceName property
+    display_device_name: Optional[str] = None
+    # The mailboxDetails property
+    mailbox_details: Optional[MailboxDetails] = None
+    # The mode property
+    mode: Optional[PlaceMode] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> Desk:
+        """
+        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: Desk
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return Desk()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .mailbox_details import MailboxDetails
+        from .place import Place
+        from .place_mode import PlaceMode
+
+        from .mailbox_details import MailboxDetails
+        from .place import Place
+        from .place_mode import PlaceMode
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "displayDeviceName": lambda n : setattr(self, 'display_device_name', n.get_str_value()),
+            "mailboxDetails": lambda n : setattr(self, 'mailbox_details', n.get_object_value(MailboxDetails)),
+            "mode": lambda n : setattr(self, 'mode', n.get_object_value(PlaceMode)),
+        }
+        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("displayDeviceName", self.display_device_name)
+        writer.write_object_value("mailboxDetails", self.mailbox_details)
+        writer.write_object_value("mode", self.mode)
+    
+

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

@@ -0,0 +1,53 @@
+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 .place_mode import PlaceMode
+
+from .place_mode import PlaceMode
+
+@dataclass
+class DropInPlaceMode(PlaceMode, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.dropInPlaceMode"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> DropInPlaceMode:
+        """
+        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: DropInPlaceMode
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return DropInPlaceMode()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .place_mode import PlaceMode
+
+        from .place_mode import PlaceMode
+
+        fields: dict[str, Callable[[Any], None]] = {
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+    
+

msgraph/generated/models/education_assignment.py

@@ -81,7 +81,7 @@ class EducationAssignment(Entity, Parsable):
     resources_folder_url: Optional[str] = None
     # When set, the grading rubric attached to this assignment.
     rubric: Optional[EducationRubric] = None
-    # Status of the assignment.  You can't PATCH this value. Possible values are: draft, scheduled, published, assigned, unknownFutureValue, inactive. Use the Prefer: include-unknown-enum-members request header to get the following value(s) in this evolvable enum: inactive.
+    # Status of the assignment.  You can't PATCH this value. Possible values are: draft, scheduled, published, assigned, unknownFutureValue, inactive. Use the Prefer: include-unknown-enum-members request header to get the following members in this evolvable enum: inactive.
     status: Optional[EducationAssignmentStatus] = None
     # Once published, there's a submission object for each student representing their work and grade. Read-only. Nullable.
     submissions: Optional[list[EducationSubmission]] = None

msgraph/generated/models/education_assignment_defaults.py

@@ -14,7 +14,7 @@ from .entity import Entity
 
 @dataclass
 class EducationAssignmentDefaults(Entity, Parsable):
-    # Optional field to control adding assignments to students' and teachers' calendars when the assignment is published. The possible values are: none, studentsAndPublisher, studentsAndTeamOwners, unknownFutureValue, and studentsOnly. Use the Prefer: include-unknown-enum-members request header to get the following value in this evolvable enum: studentsOnly. The default value is none.
+    # Optional field to control adding assignments to students' and teachers' calendars when the assignment is published. The possible values are: none, studentsAndPublisher, studentsAndTeamOwners, unknownFutureValue, and studentsOnly. Use the Prefer: include-unknown-enum-members request header to get the following members in this evolvable enum: studentsOnly. The default value is none.
     add_to_calendar_action: Optional[EducationAddToCalendarOptions] = None
     # Class-level default behavior for handling students who are added after the assignment is published. Possible values are: none, assignIfOpen.
     added_student_action: Optional[EducationAddedStudentAction] = None