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

msgraph/generated/models/level_map.py

@@ -0,0 +1,78 @@
+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 .fixture_map import FixtureMap
+    from .section_map import SectionMap
+    from .unit_map import UnitMap
+
+from .base_map_feature import BaseMapFeature
+
+@dataclass
+class LevelMap(BaseMapFeature, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.levelMap"
+    # The fixtures property
+    fixtures: Optional[list[FixtureMap]] = None
+    # The placeId property
+    place_id: Optional[str] = None
+    # The sections property
+    sections: Optional[list[SectionMap]] = None
+    # The units property
+    units: Optional[list[UnitMap]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> LevelMap:
+        """
+        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: LevelMap
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return LevelMap()
+    
+    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 .fixture_map import FixtureMap
+        from .section_map import SectionMap
+        from .unit_map import UnitMap
+
+        from .base_map_feature import BaseMapFeature
+        from .fixture_map import FixtureMap
+        from .section_map import SectionMap
+        from .unit_map import UnitMap
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "fixtures": lambda n : setattr(self, 'fixtures', n.get_collection_of_object_values(FixtureMap)),
+            "placeId": lambda n : setattr(self, 'place_id', n.get_str_value()),
+            "sections": lambda n : setattr(self, 'sections', n.get_collection_of_object_values(SectionMap)),
+            "units": lambda n : setattr(self, 'units', n.get_collection_of_object_values(UnitMap)),
+        }
+        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("fixtures", self.fixtures)
+        writer.write_str_value("placeId", self.place_id)
+        writer.write_collection_of_object_values("sections", self.sections)
+        writer.write_collection_of_object_values("units", self.units)
+    
+

msgraph/generated/models/level_map_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 .level_map import LevelMap
+
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+
+@dataclass
+class LevelMapCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[list[LevelMap]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> LevelMapCollectionResponse:
+        """
+        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: LevelMapCollectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return LevelMapCollectionResponse()
+    
+    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 .level_map import LevelMap
+
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .level_map import LevelMap
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(LevelMap)),
+        }
+        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/mailbox_details.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 MailboxDetails(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 emailAddress property
+    email_address: Optional[str] = None
+    # The externalDirectoryObjectId property
+    external_directory_object_id: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> MailboxDetails:
+        """
+        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: MailboxDetails
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return MailboxDetails()
+    
+    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]] = {
+            "emailAddress": lambda n : setattr(self, 'email_address', n.get_str_value()),
+            "externalDirectoryObjectId": lambda n : setattr(self, 'external_directory_object_id', n.get_str_value()),
+            "@odata.type": lambda n : setattr(self, 'odata_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("emailAddress", self.email_address)
+        writer.write_str_value("externalDirectoryObjectId", self.external_directory_object_id)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/on_fraud_protection_load_start_external_users_auth_handler.py

@@ -0,0 +1,60 @@
+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 .fraud_protection_configuration import FraudProtectionConfiguration
+    from .on_fraud_protection_load_start_handler import OnFraudProtectionLoadStartHandler
+
+from .on_fraud_protection_load_start_handler import OnFraudProtectionLoadStartHandler
+
+@dataclass
+class OnFraudProtectionLoadStartExternalUsersAuthHandler(OnFraudProtectionLoadStartHandler, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.onFraudProtectionLoadStartExternalUsersAuthHandler"
+    # Specifies the fraud protection configuration for sign-up events.
+    sign_up: Optional[FraudProtectionConfiguration] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> OnFraudProtectionLoadStartExternalUsersAuthHandler:
+        """
+        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: OnFraudProtectionLoadStartExternalUsersAuthHandler
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return OnFraudProtectionLoadStartExternalUsersAuthHandler()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .fraud_protection_configuration import FraudProtectionConfiguration
+        from .on_fraud_protection_load_start_handler import OnFraudProtectionLoadStartHandler
+
+        from .fraud_protection_configuration import FraudProtectionConfiguration
+        from .on_fraud_protection_load_start_handler import OnFraudProtectionLoadStartHandler
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "signUp": lambda n : setattr(self, 'sign_up', n.get_object_value(FraudProtectionConfiguration)),
+        }
+        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("signUp", self.sign_up)
+    
+

msgraph/generated/models/on_fraud_protection_load_start_handler.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from kiota_abstractions.store import BackedModel, BackingStore, BackingStoreFactorySingleton
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .on_fraud_protection_load_start_external_users_auth_handler import OnFraudProtectionLoadStartExternalUsersAuthHandler
+
+@dataclass
+class OnFraudProtectionLoadStartHandler(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
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> OnFraudProtectionLoadStartHandler:
+        """
+        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: OnFraudProtectionLoadStartHandler
+        """
+        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.onFraudProtectionLoadStartExternalUsersAuthHandler".casefold():
+            from .on_fraud_protection_load_start_external_users_auth_handler import OnFraudProtectionLoadStartExternalUsersAuthHandler
+
+            return OnFraudProtectionLoadStartExternalUsersAuthHandler()
+        return OnFraudProtectionLoadStartHandler()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .on_fraud_protection_load_start_external_users_auth_handler import OnFraudProtectionLoadStartExternalUsersAuthHandler
+
+        from .on_fraud_protection_load_start_external_users_auth_handler import OnFraudProtectionLoadStartExternalUsersAuthHandler
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "@odata.type": lambda n : setattr(self, 'odata_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("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/on_fraud_protection_load_start_listener.py

@@ -0,0 +1,60 @@
+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 .authentication_event_listener import AuthenticationEventListener
+    from .on_fraud_protection_load_start_handler import OnFraudProtectionLoadStartHandler
+
+from .authentication_event_listener import AuthenticationEventListener
+
+@dataclass
+class OnFraudProtectionLoadStartListener(AuthenticationEventListener, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.onFraudProtectionLoadStartListener"
+    # Configuration for what to invoke if the event resolves to this listener.
+    handler: Optional[OnFraudProtectionLoadStartHandler] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> OnFraudProtectionLoadStartListener:
+        """
+        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: OnFraudProtectionLoadStartListener
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return OnFraudProtectionLoadStartListener()
+    
+    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_event_listener import AuthenticationEventListener
+        from .on_fraud_protection_load_start_handler import OnFraudProtectionLoadStartHandler
+
+        from .authentication_event_listener import AuthenticationEventListener
+        from .on_fraud_protection_load_start_handler import OnFraudProtectionLoadStartHandler
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "handler": lambda n : setattr(self, 'handler', n.get_object_value(OnFraudProtectionLoadStartHandler)),
+        }
+        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("handler", self.handler)
+    
+

msgraph/generated/models/place.py

@@ -5,11 +5,17 @@ from kiota_abstractions.serialization import Parsable, ParseNode, SerializationW
 from typing import Any, Optional, TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
+    from .building import Building
+    from .check_in_claim import CheckInClaim
+    from .desk import Desk
     from .entity import Entity
+    from .floor import Floor
     from .outlook_geo_coordinates import OutlookGeoCoordinates
     from .physical_address import PhysicalAddress
     from .room import Room
     from .room_list import RoomList
+    from .section import Section
+    from .workspace import Workspace
 
 from .entity import Entity
 
@@ -17,14 +23,24 @@ from .entity import Entity
 class Place(Entity, Parsable):
     # The street address of the place.
     address: Optional[PhysicalAddress] = None
+    # The checkIns property
+    check_ins: Optional[list[CheckInClaim]] = None
     # The name associated with the place.
     display_name: Optional[str] = None
     # Specifies the place location in latitude, longitude, and (optionally) altitude coordinates.
     geo_coordinates: Optional[OutlookGeoCoordinates] = None
+    # The isWheelChairAccessible property
+    is_wheel_chair_accessible: Optional[bool] = None
+    # The label property
+    label: Optional[str] = None
     # The OdataType property
     odata_type: Optional[str] = None
+    # The parentId property
+    parent_id: Optional[str] = None
     # The phone number of the place.
     phone: Optional[str] = None
+    # The tags property
+    tags: Optional[list[str]] = None
     
     @staticmethod
     def create_from_discriminator_value(parse_node: ParseNode) -> Place:
@@ -40,6 +56,18 @@ class Place(Entity, Parsable):
             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.building".casefold():
+            from .building import Building
+
+            return Building()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.desk".casefold():
+            from .desk import Desk
+
+            return Desk()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.floor".casefold():
+            from .floor import Floor
+
+            return Floor()
         if mapping_value and mapping_value.casefold() == "#microsoft.graph.room".casefold():
             from .room import Room
 
@@ -48,6 +76,14 @@ class Place(Entity, Parsable):
             from .room_list import RoomList
 
             return RoomList()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.section".casefold():
+            from .section import Section
+
+            return Section()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.workspace".casefold():
+            from .workspace import Workspace
+
+            return Workspace()
         return Place()
     
     def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
@@ -55,23 +91,40 @@ class Place(Entity, Parsable):
         The deserialization information for the current model
         Returns: dict[str, Callable[[ParseNode], None]]
         """
+        from .building import Building
+        from .check_in_claim import CheckInClaim
+        from .desk import Desk
         from .entity import Entity
+        from .floor import Floor
         from .outlook_geo_coordinates import OutlookGeoCoordinates
         from .physical_address import PhysicalAddress
         from .room import Room
         from .room_list import RoomList
+        from .section import Section
+        from .workspace import Workspace
 
+        from .building import Building
+        from .check_in_claim import CheckInClaim
+        from .desk import Desk
         from .entity import Entity
+        from .floor import Floor
         from .outlook_geo_coordinates import OutlookGeoCoordinates
         from .physical_address import PhysicalAddress
         from .room import Room
         from .room_list import RoomList
+        from .section import Section
+        from .workspace import Workspace
 
         fields: dict[str, Callable[[Any], None]] = {
             "address": lambda n : setattr(self, 'address', n.get_object_value(PhysicalAddress)),
+            "checkIns": lambda n : setattr(self, 'check_ins', n.get_collection_of_object_values(CheckInClaim)),
             "displayName": lambda n : setattr(self, 'display_name', n.get_str_value()),
             "geoCoordinates": lambda n : setattr(self, 'geo_coordinates', n.get_object_value(OutlookGeoCoordinates)),
+            "isWheelChairAccessible": lambda n : setattr(self, 'is_wheel_chair_accessible', n.get_bool_value()),
+            "label": lambda n : setattr(self, 'label', n.get_str_value()),
+            "parentId": lambda n : setattr(self, 'parent_id', n.get_str_value()),
             "phone": lambda n : setattr(self, 'phone', n.get_str_value()),
+            "tags": lambda n : setattr(self, 'tags', n.get_collection_of_primitive_values(str)),
         }
         super_fields = super().get_field_deserializers()
         fields.update(super_fields)
@@ -87,8 +140,13 @@ class Place(Entity, Parsable):
             raise TypeError("writer cannot be null.")
         super().serialize(writer)
         writer.write_object_value("address", self.address)
+        writer.write_collection_of_object_values("checkIns", self.check_ins)
         writer.write_str_value("displayName", self.display_name)
         writer.write_object_value("geoCoordinates", self.geo_coordinates)
+        writer.write_bool_value("isWheelChairAccessible", self.is_wheel_chair_accessible)
+        writer.write_str_value("label", self.label)
+        writer.write_str_value("parentId", self.parent_id)
         writer.write_str_value("phone", self.phone)
+        writer.write_collection_of_primitive_values("tags", self.tags)
     
 

msgraph/generated/models/place_mode.py

@@ -0,0 +1,80 @@
+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 .assigned_place_mode import AssignedPlaceMode
+    from .drop_in_place_mode import DropInPlaceMode
+    from .reservable_place_mode import ReservablePlaceMode
+
+@dataclass
+class PlaceMode(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
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PlaceMode:
+        """
+        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: PlaceMode
+        """
+        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.assignedPlaceMode".casefold():
+            from .assigned_place_mode import AssignedPlaceMode
+
+            return AssignedPlaceMode()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.dropInPlaceMode".casefold():
+            from .drop_in_place_mode import DropInPlaceMode
+
+            return DropInPlaceMode()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.reservablePlaceMode".casefold():
+            from .reservable_place_mode import ReservablePlaceMode
+
+            return ReservablePlaceMode()
+        return PlaceMode()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .assigned_place_mode import AssignedPlaceMode
+        from .drop_in_place_mode import DropInPlaceMode
+        from .reservable_place_mode import ReservablePlaceMode
+
+        from .assigned_place_mode import AssignedPlaceMode
+        from .drop_in_place_mode import DropInPlaceMode
+        from .reservable_place_mode import ReservablePlaceMode
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "@odata.type": lambda n : setattr(self, 'odata_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("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/planner_plan_container.py

@@ -19,7 +19,7 @@ class PlannerPlanContainer(AdditionalDataHolder, BackedModel, Parsable):
     container_id: Optional[str] = None
     # The OdataType property
     odata_type: Optional[str] = None
-    # The type of the resource that contains the plan. For supported types, see the previous table. Possible values are: group, unknownFutureValue, roster. Use the Prefer: include-unknown-enum-members request header to get the following value in this evolvable enum: roster. Optional.
+    # The type of the resource that contains the plan. For supported types, see the previous table. Possible values are: group, unknownFutureValue, roster. Use the Prefer: include-unknown-enum-members request header to get the following members in this evolvable enum: roster. Optional.
     type: Optional[PlannerContainerType] = None
     # The full canonical URL of the container. Optional.
     url: Optional[str] = None

msgraph/generated/models/reservable_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 ReservablePlaceMode(PlaceMode, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.reservablePlaceMode"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ReservablePlaceMode:
+        """
+        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: ReservablePlaceMode
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ReservablePlaceMode()
+    
+    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)
+    
+