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

msgraph/generated/kiota-lock.json

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

msgraph/generated/models/akamai_attack_group_action_model.py

@@ -12,9 +12,9 @@ class AkamaiAttackGroupActionModel(AdditionalDataHolder, BackedModel, Parsable):
 
     # 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 action property
+    # The action Akamai applies to the attack group when a matching threat is detected. Common values include deny, none or alert.
     action: Optional[str] = None
-    # The group property
+    # The name or identifier of the attack group. This value categorizes the type of attack the action applies to.
     group: Optional[str] = None
     # The OdataType property
     odata_type: Optional[str] = None

msgraph/generated/models/akamai_custom_rule_model.py

@@ -12,13 +12,13 @@ class AkamaiCustomRuleModel(AdditionalDataHolder, BackedModel, Parsable):
 
     # 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 action property
+    # The action Akamai applies when the rule matches traffic. Common values include deny, none or alert.
     action: Optional[str] = None
-    # The name property
+    # Friendly name for the rule, used in UIs or logs to help administrators identify the rule (for example, 'Block suspicious user agents').
     name: Optional[str] = None
     # The OdataType property
     odata_type: Optional[str] = None
-    # The ruleId property
+    # Unique identifier assigned to the rule by Akamai or the integration. Use this identifier to reference, update, or remove the rule in API requests.
     rule_id: Optional[str] = None
     
     @staticmethod

msgraph/generated/models/akamai_rapid_rules_model.py

@@ -12,9 +12,9 @@ class AkamaiRapidRulesModel(AdditionalDataHolder, BackedModel, Parsable):
 
     # 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 defaultAction property
+    # The default action Akamai applies to traffic that matches Rapid Rules. Common values include deny, none or alert.
     default_action: Optional[str] = None
-    # The isEnabled property
+    # Indicates whether Akamai Rapid Rules are enabled for the WAF integration. If true, Rapid Rules are active and applied to incoming traffic.
     is_enabled: Optional[bool] = None
     # The OdataType property
     odata_type: Optional[str] = None

msgraph/generated/models/akamai_verified_details_model.py

@@ -16,11 +16,11 @@ from .web_application_firewall_verified_details import WebApplicationFirewallVer
 class AkamaiVerifiedDetailsModel(WebApplicationFirewallVerifiedDetails, Parsable):
     # The OdataType property
     odata_type: Optional[str] = "#microsoft.graph.akamaiVerifiedDetailsModel"
-    # The activeAttackGroups property
+    # Collection of Akamai attack groups that are currently active for the zone or host, including the action applied to each group (for example, deny, none or alert).
     active_attack_groups: Optional[list[AkamaiAttackGroupActionModel]] = None
-    # The activeCustomRules property
+    # Collection of Akamai custom rules that are currently enabled for the zone or host. Each entry includes rule metadata such as the rule identifier, friendly name, and the action taken when the rule matches traffic.
     active_custom_rules: Optional[list[AkamaiCustomRuleModel]] = None
-    # The rapidRules property
+    # Configuration for Akamai Rapid Rules, including whether Rapid Rules are enabled and the default action applied to matching traffic.
     rapid_rules: Optional[AkamaiRapidRulesModel] = None
     
     @staticmethod

msgraph/generated/models/akamai_web_application_firewall_provider.py

@@ -13,13 +13,13 @@ from .web_application_firewall_provider import WebApplicationFirewallProvider
 class AkamaiWebApplicationFirewallProvider(WebApplicationFirewallProvider, Parsable):
     # The OdataType property
     odata_type: Optional[str] = "#microsoft.graph.akamaiWebApplicationFirewallProvider"
-    # The accessToken property
+    # Akamai API access token used to authenticate to the Akamai account. Contact your Akamai Customer Success Manager for assistance with your accessToken.
     access_token: Optional[str] = None
-    # The clientSecret property
+    # Akamai API client secret used in conjunction with the client token and access token for authentication. Contact your Akamai Customer Success Manager for assistance with this information.
     client_secret: Optional[str] = None
-    # The clientToken property
+    # Akamai API client token used for authentication to the Akamai account. Contact your Akamai Customer Success Manager for assistance with this information.
     client_token: Optional[str] = None
-    # The hostPrefix property
+    # Prefix used to identify the host or domain in Akamai configuration operations. This value may be required for certain API calls or configuration scenarios.
     host_prefix: Optional[str] = None
     
     @staticmethod

msgraph/generated/models/arkose_fraud_protection_provider.py

@@ -0,0 +1,69 @@
+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_provider import FraudProtectionProvider
+
+from .fraud_protection_provider import FraudProtectionProvider
+
+@dataclass
+class ArkoseFraudProtectionProvider(FraudProtectionProvider, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.arkoseFraudProtectionProvider"
+    # Used to invoke the Arkose service from the client application. Request from your Arkose Customer Success Manager or use the default client-api value.
+    client_sub_domain: Optional[str] = None
+    # The private key available on the Arkose Portal. Contact your Arkose Customer Success Manager for assistance with your keys.
+    private_key: Optional[str] = None
+    # The public key available on the Arkose Portal. Contact your Arkose Customer Success Manager for assistance with your keys.
+    public_key: Optional[str] = None
+    # Used to invoke the Arkose service from the Microsoft authentication server. Request from your Arkose Customer Success Manager or use the default verify-api value.
+    verify_sub_domain: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ArkoseFraudProtectionProvider:
+        """
+        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: ArkoseFraudProtectionProvider
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ArkoseFraudProtectionProvider()
+    
+    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_provider import FraudProtectionProvider
+
+        from .fraud_protection_provider import FraudProtectionProvider
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "clientSubDomain": lambda n : setattr(self, 'client_sub_domain', n.get_str_value()),
+            "privateKey": lambda n : setattr(self, 'private_key', n.get_str_value()),
+            "publicKey": lambda n : setattr(self, 'public_key', n.get_str_value()),
+            "verifySubDomain": lambda n : setattr(self, 'verify_sub_domain', 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("clientSubDomain", self.client_sub_domain)
+        writer.write_str_value("privateKey", self.private_key)
+        writer.write_str_value("publicKey", self.public_key)
+        writer.write_str_value("verifySubDomain", self.verify_sub_domain)
+    
+

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/authentication_event_listener.py

@@ -12,6 +12,7 @@ if TYPE_CHECKING:
     from .on_attribute_collection_submit_listener import OnAttributeCollectionSubmitListener
     from .on_authentication_method_load_start_listener import OnAuthenticationMethodLoadStartListener
     from .on_email_otp_send_listener import OnEmailOtpSendListener
+    from .on_fraud_protection_load_start_listener import OnFraudProtectionLoadStartListener
     from .on_interactive_auth_flow_start_listener import OnInteractiveAuthFlowStartListener
     from .on_token_issuance_start_listener import OnTokenIssuanceStartListener
     from .on_user_create_start_listener import OnUserCreateStartListener
@@ -24,6 +25,8 @@ class AuthenticationEventListener(Entity, Parsable):
     authentication_events_flow_id: Optional[str] = None
     # The conditions on which this authenticationEventListener should trigger.
     conditions: Optional[AuthenticationConditions] = None
+    # The display name of the listener.
+    display_name: Optional[str] = None
     # The OdataType property
     odata_type: Optional[str] = None
     
@@ -61,6 +64,10 @@ class AuthenticationEventListener(Entity, Parsable):
             from .on_email_otp_send_listener import OnEmailOtpSendListener
 
             return OnEmailOtpSendListener()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.onFraudProtectionLoadStartListener".casefold():
+            from .on_fraud_protection_load_start_listener import OnFraudProtectionLoadStartListener
+
+            return OnFraudProtectionLoadStartListener()
         if mapping_value and mapping_value.casefold() == "#microsoft.graph.onInteractiveAuthFlowStartListener".casefold():
             from .on_interactive_auth_flow_start_listener import OnInteractiveAuthFlowStartListener
 
@@ -87,6 +94,7 @@ class AuthenticationEventListener(Entity, Parsable):
         from .on_attribute_collection_submit_listener import OnAttributeCollectionSubmitListener
         from .on_authentication_method_load_start_listener import OnAuthenticationMethodLoadStartListener
         from .on_email_otp_send_listener import OnEmailOtpSendListener
+        from .on_fraud_protection_load_start_listener import OnFraudProtectionLoadStartListener
         from .on_interactive_auth_flow_start_listener import OnInteractiveAuthFlowStartListener
         from .on_token_issuance_start_listener import OnTokenIssuanceStartListener
         from .on_user_create_start_listener import OnUserCreateStartListener
@@ -98,6 +106,7 @@ class AuthenticationEventListener(Entity, Parsable):
         from .on_attribute_collection_submit_listener import OnAttributeCollectionSubmitListener
         from .on_authentication_method_load_start_listener import OnAuthenticationMethodLoadStartListener
         from .on_email_otp_send_listener import OnEmailOtpSendListener
+        from .on_fraud_protection_load_start_listener import OnFraudProtectionLoadStartListener
         from .on_interactive_auth_flow_start_listener import OnInteractiveAuthFlowStartListener
         from .on_token_issuance_start_listener import OnTokenIssuanceStartListener
         from .on_user_create_start_listener import OnUserCreateStartListener
@@ -105,6 +114,7 @@ class AuthenticationEventListener(Entity, Parsable):
         fields: dict[str, Callable[[Any], None]] = {
             "authenticationEventsFlowId": lambda n : setattr(self, 'authentication_events_flow_id', n.get_str_value()),
             "conditions": lambda n : setattr(self, 'conditions', n.get_object_value(AuthenticationConditions)),
+            "displayName": lambda n : setattr(self, 'display_name', n.get_str_value()),
         }
         super_fields = super().get_field_deserializers()
         fields.update(super_fields)
@@ -121,5 +131,6 @@ class AuthenticationEventListener(Entity, Parsable):
         super().serialize(writer)
         writer.write_str_value("authenticationEventsFlowId", self.authentication_events_flow_id)
         writer.write_object_value("conditions", self.conditions)
+        writer.write_str_value("displayName", self.display_name)
     
 

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/check_in_claim.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+import datetime
+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 .check_in_method import CheckInMethod
+
+@dataclass
+class CheckInClaim(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 calendarEventId property
+    calendar_event_id: Optional[str] = None
+    # The checkInMethod property
+    check_in_method: Optional[CheckInMethod] = None
+    # The createdDateTime property
+    created_date_time: Optional[datetime.datetime] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> CheckInClaim:
+        """
+        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: CheckInClaim
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return CheckInClaim()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .check_in_method import CheckInMethod
+
+        from .check_in_method import CheckInMethod
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "calendarEventId": lambda n : setattr(self, 'calendar_event_id', n.get_str_value()),
+            "checkInMethod": lambda n : setattr(self, 'check_in_method', n.get_enum_value(CheckInMethod)),
+            "createdDateTime": lambda n : setattr(self, 'created_date_time', n.get_datetime_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("calendarEventId", self.calendar_event_id)
+        writer.write_enum_value("checkInMethod", self.check_in_method)
+        writer.write_datetime_value("createdDateTime", self.created_date_time)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+