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

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

@@ -0,0 +1,57 @@
+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 import Place
+
+from .place import Place
+
+@dataclass
+class Floor(Place, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.floor"
+    # The sortOrder property
+    sort_order: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> Floor:
+        """
+        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: Floor
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return Floor()
+    
+    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 import Place
+
+        from .place import Place
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "sortOrder": lambda n : setattr(self, 'sort_order', n.get_int_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_int_value("sortOrder", self.sort_order)
+    
+

msgraph/generated/models/floor_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 .floor import Floor
+
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+
+@dataclass
+class FloorCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[list[Floor]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> FloorCollectionResponse:
+        """
+        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: FloorCollectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return FloorCollectionResponse()
+    
+    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 .floor import Floor
+
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .floor import Floor
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(Floor)),
+        }
+        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/footprint_map.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 .base_map_feature import BaseMapFeature
+
+from .base_map_feature import BaseMapFeature
+
+@dataclass
+class FootprintMap(BaseMapFeature, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.footprintMap"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> FootprintMap:
+        """
+        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: FootprintMap
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return FootprintMap()
+    
+    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 .base_map_feature import BaseMapFeature
+
+        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/footprint_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 .footprint_map import FootprintMap
+
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+
+@dataclass
+class FootprintMapCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[list[FootprintMap]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> FootprintMapCollectionResponse:
+        """
+        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: FootprintMapCollectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return FootprintMapCollectionResponse()
+    
+    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 .footprint_map import FootprintMap
+
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .footprint_map import FootprintMap
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(FootprintMap)),
+        }
+        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/identity_governance/user_inactivity_trigger.py

@@ -0,0 +1,57 @@
+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 .workflow_execution_trigger import WorkflowExecutionTrigger
+
+from .workflow_execution_trigger import WorkflowExecutionTrigger
+
+@dataclass
+class UserInactivityTrigger(WorkflowExecutionTrigger, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.identityGovernance.userInactivityTrigger"
+    # The number of days a user must be inactive before triggering workflow execution.
+    inactivity_period_in_days: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserInactivityTrigger:
+        """
+        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: UserInactivityTrigger
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserInactivityTrigger()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .workflow_execution_trigger import WorkflowExecutionTrigger
+
+        from .workflow_execution_trigger import WorkflowExecutionTrigger
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "inactivityPeriodInDays": lambda n : setattr(self, 'inactivity_period_in_days', n.get_int_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_int_value("inactivityPeriodInDays", self.inactivity_period_in_days)
+    
+

msgraph/generated/models/identity_governance/workflow_execution_trigger.py

@@ -9,6 +9,7 @@ if TYPE_CHECKING:
     from .attribute_change_trigger import AttributeChangeTrigger
     from .membership_change_trigger import MembershipChangeTrigger
     from .time_based_attribute_trigger import TimeBasedAttributeTrigger
+    from .user_inactivity_trigger import UserInactivityTrigger
 
 @dataclass
 class WorkflowExecutionTrigger(AdditionalDataHolder, BackedModel, Parsable):
@@ -46,6 +47,10 @@ class WorkflowExecutionTrigger(AdditionalDataHolder, BackedModel, Parsable):
             from .time_based_attribute_trigger import TimeBasedAttributeTrigger
 
             return TimeBasedAttributeTrigger()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.identityGovernance.userInactivityTrigger".casefold():
+            from .user_inactivity_trigger import UserInactivityTrigger
+
+            return UserInactivityTrigger()
         return WorkflowExecutionTrigger()
     
     def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
@@ -56,10 +61,12 @@ class WorkflowExecutionTrigger(AdditionalDataHolder, BackedModel, Parsable):
         from .attribute_change_trigger import AttributeChangeTrigger
         from .membership_change_trigger import MembershipChangeTrigger
         from .time_based_attribute_trigger import TimeBasedAttributeTrigger
+        from .user_inactivity_trigger import UserInactivityTrigger
 
         from .attribute_change_trigger import AttributeChangeTrigger
         from .membership_change_trigger import MembershipChangeTrigger
         from .time_based_attribute_trigger import TimeBasedAttributeTrigger
+        from .user_inactivity_trigger import UserInactivityTrigger
 
         fields: dict[str, Callable[[Any], None]] = {
             "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),

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)
+    
+