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

msgraph/generated/kiota-lock.json

@@ -1,8 +1,8 @@
 {
-  "descriptionHash": "645999DA4E657EB400D8A694456CA5F9D1E62FE46056F8B00797AD20C48BFD4522A925588EF4DD2AD33AE76361C65DDDEDB5C4C77BE6167C97F26B389CDD0E3D",
+  "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/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)
     

msgraph/generated/models/data_security_and_governance.py

@@ -6,6 +6,7 @@ from typing import Any, Optional, TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
     from .entity import Entity
+    from .sensitivity_label import SensitivityLabel
     from .tenant_data_security_and_governance import TenantDataSecurityAndGovernance
     from .user_data_security_and_governance import UserDataSecurityAndGovernance
 
@@ -15,6 +16,8 @@ from .entity import Entity
 class DataSecurityAndGovernance(Entity, Parsable):
     # 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) -> DataSecurityAndGovernance:
@@ -46,14 +49,17 @@ class DataSecurityAndGovernance(Entity, Parsable):
         Returns: dict[str, Callable[[ParseNode], None]]
         """
         from .entity import Entity
+        from .sensitivity_label import SensitivityLabel
         from .tenant_data_security_and_governance import TenantDataSecurityAndGovernance
         from .user_data_security_and_governance import UserDataSecurityAndGovernance
 
         from .entity import Entity
+        from .sensitivity_label import SensitivityLabel
         from .tenant_data_security_and_governance import TenantDataSecurityAndGovernance
         from .user_data_security_and_governance import UserDataSecurityAndGovernance
 
         fields: dict[str, Callable[[Any], None]] = {
+            "sensitivityLabels": lambda n : setattr(self, 'sensitivity_labels', n.get_collection_of_object_values(SensitivityLabel)),
         }
         super_fields = super().get_field_deserializers()
         fields.update(super_fields)
@@ -68,5 +74,6 @@ class DataSecurityAndGovernance(Entity, Parsable):
         if writer is None:
             raise TypeError("writer cannot be null.")
         super().serialize(writer)
+        writer.write_collection_of_object_values("sensitivityLabels", self.sensitivity_labels)
     
 

msgraph/generated/models/drive_recipient.py

@@ -12,7 +12,7 @@ class DriveRecipient(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 alias of the domain object, for cases where an email address is unavailable (e.g. security groups).
+    # The alias of the domain object, for cases where an email address is unavailable (for example, security groups).
     alias: Optional[str] = None
     # The email address for the recipient, if the recipient has an associated email address.
     email: Optional[str] = None

msgraph/generated/models/entity.py

@@ -654,6 +654,9 @@ if TYPE_CHECKING:
     from .security.article import Article
     from .security.article_indicator import ArticleIndicator
     from .security.artifact import Artifact
+    from .security.audit_core_root import AuditCoreRoot
+    from .security.audit_log_query import AuditLogQuery
+    from .security.audit_log_record import AuditLogRecord
     from .security.authority_template import AuthorityTemplate
     from .security.case import Case
     from .security.cases_root import CasesRoot
@@ -727,6 +730,7 @@ if TYPE_CHECKING:
     from .security.whois_record import WhoisRecord
     from .security_reports_root import SecurityReportsRoot
     from .send_dtmf_tones_operation import SendDtmfTonesOperation
+    from .sensitivity_label import SensitivityLabel
     from .service_announcement import ServiceAnnouncement
     from .service_announcement_attachment import ServiceAnnouncementAttachment
     from .service_announcement_base import ServiceAnnouncementBase
@@ -3635,6 +3639,18 @@ class Entity(AdditionalDataHolder, BackedModel, Parsable):
             from .security.artifact import Artifact
 
             return Artifact()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.security.auditCoreRoot".casefold():
+            from .security.audit_core_root import AuditCoreRoot
+
+            return AuditCoreRoot()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.security.auditLogQuery".casefold():
+            from .security.audit_log_query import AuditLogQuery
+
+            return AuditLogQuery()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.security.auditLogRecord".casefold():
+            from .security.audit_log_record import AuditLogRecord
+
+            return AuditLogRecord()
         if mapping_value and mapping_value.casefold() == "#microsoft.graph.security.authorityTemplate".casefold():
             from .security.authority_template import AuthorityTemplate
 
@@ -3924,6 +3940,10 @@ class Entity(AdditionalDataHolder, BackedModel, Parsable):
             from .send_dtmf_tones_operation import SendDtmfTonesOperation
 
             return SendDtmfTonesOperation()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.sensitivityLabel".casefold():
+            from .sensitivity_label import SensitivityLabel
+
+            return SensitivityLabel()
         if mapping_value and mapping_value.casefold() == "#microsoft.graph.serviceAnnouncement".casefold():
             from .service_announcement import ServiceAnnouncement
 
@@ -5688,6 +5708,9 @@ class Entity(AdditionalDataHolder, BackedModel, Parsable):
         from .security.article import Article
         from .security.article_indicator import ArticleIndicator
         from .security.artifact import Artifact
+        from .security.audit_core_root import AuditCoreRoot
+        from .security.audit_log_query import AuditLogQuery
+        from .security.audit_log_record import AuditLogRecord
         from .security.authority_template import AuthorityTemplate
         from .security.case import Case
         from .security.cases_root import CasesRoot
@@ -5761,6 +5784,7 @@ class Entity(AdditionalDataHolder, BackedModel, Parsable):
         from .security.whois_record import WhoisRecord
         from .security_reports_root import SecurityReportsRoot
         from .send_dtmf_tones_operation import SendDtmfTonesOperation
+        from .sensitivity_label import SensitivityLabel
         from .service_announcement import ServiceAnnouncement
         from .service_announcement_attachment import ServiceAnnouncementAttachment
         from .service_announcement_base import ServiceAnnouncementBase
@@ -6687,6 +6711,9 @@ class Entity(AdditionalDataHolder, BackedModel, Parsable):
         from .security.article import Article
         from .security.article_indicator import ArticleIndicator
         from .security.artifact import Artifact
+        from .security.audit_core_root import AuditCoreRoot
+        from .security.audit_log_query import AuditLogQuery
+        from .security.audit_log_record import AuditLogRecord
         from .security.authority_template import AuthorityTemplate
         from .security.case import Case
         from .security.cases_root import CasesRoot
@@ -6760,6 +6787,7 @@ class Entity(AdditionalDataHolder, BackedModel, Parsable):
         from .security.whois_record import WhoisRecord
         from .security_reports_root import SecurityReportsRoot
         from .send_dtmf_tones_operation import SendDtmfTonesOperation
+        from .sensitivity_label import SensitivityLabel
         from .service_announcement import ServiceAnnouncement
         from .service_announcement_attachment import ServiceAnnouncementAttachment
         from .service_announcement_base import ServiceAnnouncementBase

msgraph/generated/models/fido2_authentication_method_configuration.py

@@ -21,7 +21,7 @@ class Fido2AuthenticationMethodConfiguration(AuthenticationMethodConfiguration,
     is_attestation_enforced: Optional[bool] = None
     # Determines if users can register new FIDO2 security keys.
     is_self_service_registration_allowed: Optional[bool] = None
-    # Controls whether key restrictions are enforced on FIDO2 security keys, either allowing or disallowing certain key types as defined by Authenticator Attestation GUID (AAGUID), an identifier that indicates the type (e.g. make and model) of the authenticator.
+    # Controls whether key restrictions are enforced on FIDO2 security keys, either allowing or disallowing certain key types as defined by Authenticator Attestation GUID (AAGUID), an identifier that indicates the type (for example, make and model) of the authenticator.
     key_restrictions: Optional[Fido2KeyRestrictions] = None
     
     @staticmethod

msgraph/generated/models/label_action_source.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class LabelActionSource(str, Enum):
+    Manual = "manual",
+    Automatic = "automatic",
+    Recommended = "recommended",
+    None_ = "none",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/label_content_right.py

@@ -6,6 +6,8 @@ from typing import Any, Optional, TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
     from .entity import Entity
+    from .sensitivity_label import SensitivityLabel
+    from .usage_rights import UsageRights
 
 from .entity import Entity
 
@@ -15,8 +17,12 @@ class LabelContentRight(Entity, Parsable):
     cid: Optional[str] = None
     # The content format.
     format: Optional[str] = None
+    # The label property
+    label: Optional[SensitivityLabel] = None
     # The OdataType property
     odata_type: Optional[str] = None
+    # The rights property
+    rights: Optional[UsageRights] = None
     
     @staticmethod
     def create_from_discriminator_value(parse_node: ParseNode) -> LabelContentRight:
@@ -35,12 +41,18 @@ class LabelContentRight(Entity, Parsable):
         Returns: dict[str, Callable[[ParseNode], None]]
         """
         from .entity import Entity
+        from .sensitivity_label import SensitivityLabel
+        from .usage_rights import UsageRights
 
         from .entity import Entity
+        from .sensitivity_label import SensitivityLabel
+        from .usage_rights import UsageRights
 
         fields: dict[str, Callable[[Any], None]] = {
             "cid": lambda n : setattr(self, 'cid', n.get_str_value()),
             "format": lambda n : setattr(self, 'format', n.get_str_value()),
+            "label": lambda n : setattr(self, 'label', n.get_object_value(SensitivityLabel)),
+            "rights": lambda n : setattr(self, 'rights', n.get_collection_of_enum_values(UsageRights)),
         }
         super_fields = super().get_field_deserializers()
         fields.update(super_fields)
@@ -57,5 +69,7 @@ class LabelContentRight(Entity, Parsable):
         super().serialize(writer)
         writer.write_str_value("cid", self.cid)
         writer.write_str_value("format", self.format)
+        writer.write_object_value("label", self.label)
+        writer.write_enum_value("rights", self.rights)
     
 

msgraph/generated/models/protected_content.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 ProtectedContent(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 content id
+    cid: Optional[str] = None
+    # The content format.
+    format: Optional[str] = None
+    # The unique identifier for the sensitivity label applied to the content.
+    label_id: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ProtectedContent:
+        """
+        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: ProtectedContent
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ProtectedContent()
+    
+    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]] = {
+            "cid": lambda n : setattr(self, 'cid', n.get_str_value()),
+            "format": lambda n : setattr(self, 'format', n.get_str_value()),
+            "labelId": lambda n : setattr(self, 'label_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("cid", self.cid)
+        writer.write_str_value("format", self.format)
+        writer.write_str_value("labelId", self.label_id)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/secure_sign_in_session_control.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 .conditional_access_session_control import ConditionalAccessSessionControl
+
+from .conditional_access_session_control import ConditionalAccessSessionControl
+
+@dataclass
+class SecureSignInSessionControl(ConditionalAccessSessionControl, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.secureSignInSessionControl"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SecureSignInSessionControl:
+        """
+        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: SecureSignInSessionControl
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SecureSignInSessionControl()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .conditional_access_session_control import ConditionalAccessSessionControl
+
+        from .conditional_access_session_control import ConditionalAccessSessionControl
+
+        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/security/aad_risk_detection_audit_record.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 .audit_data import AuditData
+
+from .audit_data import AuditData
+
+@dataclass
+class AadRiskDetectionAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.aadRiskDetectionAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AadRiskDetectionAuditRecord:
+        """
+        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: AadRiskDetectionAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AadRiskDetectionAuditRecord()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .audit_data import AuditData
+
+        from .audit_data import AuditData
+
+        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/security/aed_audit_record.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 .audit_data import AuditData
+
+from .audit_data import AuditData
+
+@dataclass
+class AedAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.aedAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AedAuditRecord:
+        """
+        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: AedAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AedAuditRecord()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .audit_data import AuditData
+
+        from .audit_data import AuditData
+
+        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/security/ai_app_interaction_audit_record.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 .audit_data import AuditData
+
+from .audit_data import AuditData
+
+@dataclass
+class AiAppInteractionAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.aiAppInteractionAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AiAppInteractionAuditRecord:
+        """
+        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: AiAppInteractionAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AiAppInteractionAuditRecord()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .audit_data import AuditData
+
+        from .audit_data import AuditData
+
+        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)
+    
+