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

msgraph/generated/kiota-lock.json

@@ -1,8 +1,8 @@
 {
-  "descriptionHash": "D30AE728B02B4955989D20416397BFCF71ACE641A7F6394AB926849E078B3ADAC03C2E4AC6219CDBAD366474CD6FE047BAA29452865D993B65AE503698935A13",
+  "descriptionHash": "F66F35AF42DFD96FE735D23A13B33683547FA331442A856BCC89322EB087DAA1BB96F0AF787D4DA6C09602408DE805BDAC8EAD927DB56D532AC2A62171CF5CDF",
   "descriptionLocation": "../../msgraph-metadata/clean_v10_openapi/openapi.yaml",
   "lockFileVersion": "1.0.0",
-  "kiotaVersion": "1.28.0",
+  "kiotaVersion": "1.29.0",
   "clientClassName": "BaseGraphServiceClient",
   "typeAccessModifier": "Public",
   "clientNamespaceName": "msgraph.generated",

msgraph/generated/models/activities_container.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 .content_activity import ContentActivity
+    from .entity import Entity
+
+from .entity import Entity
+
+@dataclass
+class ActivitiesContainer(Entity, Parsable):
+    # Collection of activity logs related to content processing.
+    content_activities: Optional[list[ContentActivity]] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ActivitiesContainer:
+        """
+        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: ActivitiesContainer
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ActivitiesContainer()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .content_activity import ContentActivity
+        from .entity import Entity
+
+        from .content_activity import ContentActivity
+        from .entity import Entity
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "contentActivities": lambda n : setattr(self, 'content_activities', n.get_collection_of_object_values(ContentActivity)),
+        }
+        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("contentActivities", self.content_activities)
+    
+

msgraph/generated/models/activity_metadata.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from kiota_abstractions.store import BackedModel, BackingStore, BackingStoreFactorySingleton
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .user_activity_type import UserActivityType
+
+@dataclass
+class ActivityMetadata(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 activity property
+    activity: Optional[UserActivityType] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ActivityMetadata:
+        """
+        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: ActivityMetadata
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ActivityMetadata()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .user_activity_type import UserActivityType
+
+        from .user_activity_type import UserActivityType
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "activity": lambda n : setattr(self, 'activity', n.get_enum_value(UserActivityType)),
+            "@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_enum_value("activity", self.activity)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/ai_interaction_plugin.py

@@ -0,0 +1,62 @@
+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 AiInteractionPlugin(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 unique identifier of the plugin.
+    identifier: Optional[str] = None
+    # The display name of the plugin.
+    name: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The version of the plugin used.
+    version: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AiInteractionPlugin:
+        """
+        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: AiInteractionPlugin
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AiInteractionPlugin()
+    
+    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]] = {
+            "identifier": lambda n : setattr(self, 'identifier', n.get_str_value()),
+            "name": lambda n : setattr(self, 'name', n.get_str_value()),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "version": lambda n : setattr(self, 'version', 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("identifier", self.identifier)
+        writer.write_str_value("name", self.name)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_str_value("version", self.version)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/binary_content.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 .content_base import ContentBase
+
+from .content_base import ContentBase
+
+@dataclass
+class BinaryContent(ContentBase, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.binaryContent"
+    # The binary content, encoded as a Base64 string. Inherited from contentBase.
+    data: Optional[bytes] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> BinaryContent:
+        """
+        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: BinaryContent
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return BinaryContent()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .content_base import ContentBase
+
+        from .content_base import ContentBase
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "data": lambda n : setattr(self, 'data', n.get_bytes_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_bytes_value("data", self.data)
+    
+

msgraph/generated/models/classifcation_error_base.py

@@ -0,0 +1,92 @@
+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 .classification_error import ClassificationError
+    from .classification_inner_error import ClassificationInnerError
+    from .processing_error import ProcessingError
+
+@dataclass
+class ClassifcationErrorBase(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)
+    # A service-defined error code string.
+    code: Optional[str] = None
+    # Contains more specific, potentially internal error details.
+    inner_error: Optional[ClassificationInnerError] = None
+    # A human-readable representation of the error.
+    message: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The target of the error (for example, the specific property or item causing the issue).
+    target: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ClassifcationErrorBase:
+        """
+        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: ClassifcationErrorBase
+        """
+        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.classificationError".casefold():
+            from .classification_error import ClassificationError
+
+            return ClassificationError()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.processingError".casefold():
+            from .processing_error import ProcessingError
+
+            return ProcessingError()
+        return ClassifcationErrorBase()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .classification_error import ClassificationError
+        from .classification_inner_error import ClassificationInnerError
+        from .processing_error import ProcessingError
+
+        from .classification_error import ClassificationError
+        from .classification_inner_error import ClassificationInnerError
+        from .processing_error import ProcessingError
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "code": lambda n : setattr(self, 'code', n.get_str_value()),
+            "innerError": lambda n : setattr(self, 'inner_error', n.get_object_value(ClassificationInnerError)),
+            "message": lambda n : setattr(self, 'message', n.get_str_value()),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "target": lambda n : setattr(self, 'target', 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("code", self.code)
+        writer.write_object_value("innerError", self.inner_error)
+        writer.write_str_value("message", self.message)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_str_value("target", self.target)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/classification_error.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 .classifcation_error_base import ClassifcationErrorBase
+    from .processing_error import ProcessingError
+
+from .classifcation_error_base import ClassifcationErrorBase
+
+@dataclass
+class ClassificationError(ClassifcationErrorBase, Parsable):
+    # A collection of more specific errors contributing to the overall error.
+    details: Optional[list[ClassifcationErrorBase]] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ClassificationError:
+        """
+        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: ClassificationError
+        """
+        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.processingError".casefold():
+            from .processing_error import ProcessingError
+
+            return ProcessingError()
+        return ClassificationError()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .classifcation_error_base import ClassifcationErrorBase
+        from .processing_error import ProcessingError
+
+        from .classifcation_error_base import ClassifcationErrorBase
+        from .processing_error import ProcessingError
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "details": lambda n : setattr(self, 'details', n.get_collection_of_object_values(ClassifcationErrorBase)),
+        }
+        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("details", self.details)
+    
+

msgraph/generated/models/classification_inner_error.py

@@ -0,0 +1,67 @@
+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
+
+@dataclass
+class ClassificationInnerError(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 activity ID associated with the request that generated the error.
+    activity_id: Optional[str] = None
+    # The client request ID, if provided by the caller.
+    client_request_id: Optional[str] = None
+    # A more specific, potentially internal, error code string.
+    code: Optional[str] = None
+    # The date and time the inner error occurred.
+    error_date_time: Optional[datetime.datetime] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ClassificationInnerError:
+        """
+        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: ClassificationInnerError
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ClassificationInnerError()
+    
+    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]] = {
+            "activityId": lambda n : setattr(self, 'activity_id', n.get_str_value()),
+            "clientRequestId": lambda n : setattr(self, 'client_request_id', n.get_str_value()),
+            "code": lambda n : setattr(self, 'code', n.get_str_value()),
+            "errorDateTime": lambda n : setattr(self, 'error_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("activityId", self.activity_id)
+        writer.write_str_value("clientRequestId", self.client_request_id)
+        writer.write_str_value("code", self.code)
+        writer.write_datetime_value("errorDateTime", self.error_date_time)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/compute_rights_and_inheritance_result.py

@@ -0,0 +1,72 @@
+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 .label_content_right import LabelContentRight
+    from .sensitivity_label import SensitivityLabel
+
+@dataclass
+class ComputeRightsAndInheritanceResult(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 contentRights property
+    content_rights: Optional[list[LabelContentRight]] = None
+    # The inheritedLabel property
+    inherited_label: Optional[SensitivityLabel] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The sensitivityLabels property
+    sensitivity_labels: Optional[list[SensitivityLabel]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ComputeRightsAndInheritanceResult:
+        """
+        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: ComputeRightsAndInheritanceResult
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ComputeRightsAndInheritanceResult()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .label_content_right import LabelContentRight
+        from .sensitivity_label import SensitivityLabel
+
+        from .label_content_right import LabelContentRight
+        from .sensitivity_label import SensitivityLabel
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "contentRights": lambda n : setattr(self, 'content_rights', n.get_collection_of_object_values(LabelContentRight)),
+            "inheritedLabel": lambda n : setattr(self, 'inherited_label', n.get_object_value(SensitivityLabel)),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "sensitivityLabels": lambda n : setattr(self, 'sensitivity_labels', n.get_collection_of_object_values(SensitivityLabel)),
+        }
+        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_collection_of_object_values("contentRights", self.content_rights)
+        writer.write_object_value("inheritedLabel", self.inherited_label)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_collection_of_object_values("sensitivityLabels", self.sensitivity_labels)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/conditional_access_session_control.py

@@ -9,6 +9,7 @@ if TYPE_CHECKING:
     from .application_enforced_restrictions_session_control import ApplicationEnforcedRestrictionsSessionControl
     from .cloud_app_security_session_control import CloudAppSecuritySessionControl
     from .persistent_browser_session_control import PersistentBrowserSessionControl
+    from .secure_sign_in_session_control import SecureSignInSessionControl
     from .sign_in_frequency_session_control import SignInFrequencySessionControl
 
 @dataclass
@@ -49,6 +50,10 @@ class ConditionalAccessSessionControl(AdditionalDataHolder, BackedModel, Parsabl
             from .persistent_browser_session_control import PersistentBrowserSessionControl
 
             return PersistentBrowserSessionControl()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.secureSignInSessionControl".casefold():
+            from .secure_sign_in_session_control import SecureSignInSessionControl
+
+            return SecureSignInSessionControl()
         if mapping_value and mapping_value.casefold() == "#microsoft.graph.signInFrequencySessionControl".casefold():
             from .sign_in_frequency_session_control import SignInFrequencySessionControl
 
@@ -63,11 +68,13 @@ class ConditionalAccessSessionControl(AdditionalDataHolder, BackedModel, Parsabl
         from .application_enforced_restrictions_session_control import ApplicationEnforcedRestrictionsSessionControl
         from .cloud_app_security_session_control import CloudAppSecuritySessionControl
         from .persistent_browser_session_control import PersistentBrowserSessionControl
+        from .secure_sign_in_session_control import SecureSignInSessionControl
         from .sign_in_frequency_session_control import SignInFrequencySessionControl
 
         from .application_enforced_restrictions_session_control import ApplicationEnforcedRestrictionsSessionControl
         from .cloud_app_security_session_control import CloudAppSecuritySessionControl
         from .persistent_browser_session_control import PersistentBrowserSessionControl
+        from .secure_sign_in_session_control import SecureSignInSessionControl
         from .sign_in_frequency_session_control import SignInFrequencySessionControl
 
         fields: dict[str, Callable[[Any], None]] = {

msgraph/generated/models/conditional_access_session_controls.py

@@ -9,6 +9,7 @@ if TYPE_CHECKING:
     from .application_enforced_restrictions_session_control import ApplicationEnforcedRestrictionsSessionControl
     from .cloud_app_security_session_control import CloudAppSecuritySessionControl
     from .persistent_browser_session_control import PersistentBrowserSessionControl
+    from .secure_sign_in_session_control import SecureSignInSessionControl
     from .sign_in_frequency_session_control import SignInFrequencySessionControl
 
 @dataclass
@@ -28,6 +29,8 @@ class ConditionalAccessSessionControls(AdditionalDataHolder, BackedModel, Parsab
     odata_type: Optional[str] = None
     # Session control to define whether to persist cookies or not. All apps should be selected for this session control to work correctly.
     persistent_browser: Optional[PersistentBrowserSessionControl] = None
+    # The secureSignInSession property
+    secure_sign_in_session: Optional[SecureSignInSessionControl] = None
     # Session control to enforce signin frequency.
     sign_in_frequency: Optional[SignInFrequencySessionControl] = None
     
@@ -50,11 +53,13 @@ class ConditionalAccessSessionControls(AdditionalDataHolder, BackedModel, Parsab
         from .application_enforced_restrictions_session_control import ApplicationEnforcedRestrictionsSessionControl
         from .cloud_app_security_session_control import CloudAppSecuritySessionControl
         from .persistent_browser_session_control import PersistentBrowserSessionControl
+        from .secure_sign_in_session_control import SecureSignInSessionControl
         from .sign_in_frequency_session_control import SignInFrequencySessionControl
 
         from .application_enforced_restrictions_session_control import ApplicationEnforcedRestrictionsSessionControl
         from .cloud_app_security_session_control import CloudAppSecuritySessionControl
         from .persistent_browser_session_control import PersistentBrowserSessionControl
+        from .secure_sign_in_session_control import SecureSignInSessionControl
         from .sign_in_frequency_session_control import SignInFrequencySessionControl
 
         fields: dict[str, Callable[[Any], None]] = {
@@ -63,6 +68,7 @@ class ConditionalAccessSessionControls(AdditionalDataHolder, BackedModel, Parsab
             "disableResilienceDefaults": lambda n : setattr(self, 'disable_resilience_defaults', n.get_bool_value()),
             "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
             "persistentBrowser": lambda n : setattr(self, 'persistent_browser', n.get_object_value(PersistentBrowserSessionControl)),
+            "secureSignInSession": lambda n : setattr(self, 'secure_sign_in_session', n.get_object_value(SecureSignInSessionControl)),
             "signInFrequency": lambda n : setattr(self, 'sign_in_frequency', n.get_object_value(SignInFrequencySessionControl)),
         }
         return fields
@@ -80,6 +86,7 @@ class ConditionalAccessSessionControls(AdditionalDataHolder, BackedModel, Parsab
         writer.write_bool_value("disableResilienceDefaults", self.disable_resilience_defaults)
         writer.write_str_value("@odata.type", self.odata_type)
         writer.write_object_value("persistentBrowser", self.persistent_browser)
+        writer.write_object_value("secureSignInSession", self.secure_sign_in_session)
         writer.write_object_value("signInFrequency", self.sign_in_frequency)
         writer.write_additional_data_value(self.additional_data)