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

msgraph/generated/models/security/quarantine_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 QuarantineAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.quarantineAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> QuarantineAuditRecord:
+        """
+        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: QuarantineAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return QuarantineAuditRecord()
+    
+    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/records_management_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 RecordsManagementAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.recordsManagementAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> RecordsManagementAuditRecord:
+        """
+        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: RecordsManagementAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return RecordsManagementAuditRecord()
+    
+    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/retention_policy_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 RetentionPolicyAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.retentionPolicyAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> RetentionPolicyAuditRecord:
+        """
+        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: RetentionPolicyAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return RetentionPolicyAuditRecord()
+    
+    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/score_evidence.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 ScoreEvidence(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.scoreEvidence"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ScoreEvidence:
+        """
+        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: ScoreEvidence
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ScoreEvidence()
+    
+    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/score_platform_generic_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 ScorePlatformGenericAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.scorePlatformGenericAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ScorePlatformGenericAuditRecord:
+        """
+        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: ScorePlatformGenericAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ScorePlatformGenericAuditRecord()
+    
+    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/script_run_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 ScriptRunAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.scriptRunAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ScriptRunAuditRecord:
+        """
+        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: ScriptRunAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ScriptRunAuditRecord()
+    
+    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/search_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 SearchAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.searchAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SearchAuditRecord:
+        """
+        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: SearchAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SearchAuditRecord()
+    
+    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/security.py

@@ -13,6 +13,7 @@ if TYPE_CHECKING:
     from ..subject_rights_request import SubjectRightsRequest
     from ..tenant_data_security_and_governance import TenantDataSecurityAndGovernance
     from .alert import Alert
+    from .audit_core_root import AuditCoreRoot
     from .cases_root import CasesRoot
     from .identity_container import IdentityContainer
     from .incident import Incident
@@ -31,6 +32,8 @@ class Security(Entity, Parsable):
     alerts_v2: Optional[list[Alert]] = None
     # The attackSimulation property
     attack_simulation: Optional[AttackSimulationRoot] = None
+    # The auditLog property
+    audit_log: Optional[AuditCoreRoot] = None
     # The cases property
     cases: Optional[CasesRoot] = None
     # The dataSecurityAndGovernance property
@@ -80,6 +83,7 @@ class Security(Entity, Parsable):
         from ..subject_rights_request import SubjectRightsRequest
         from ..tenant_data_security_and_governance import TenantDataSecurityAndGovernance
         from .alert import Alert
+        from .audit_core_root import AuditCoreRoot
         from .cases_root import CasesRoot
         from .identity_container import IdentityContainer
         from .incident import Incident
@@ -96,6 +100,7 @@ class Security(Entity, Parsable):
         from ..subject_rights_request import SubjectRightsRequest
         from ..tenant_data_security_and_governance import TenantDataSecurityAndGovernance
         from .alert import Alert
+        from .audit_core_root import AuditCoreRoot
         from .cases_root import CasesRoot
         from .identity_container import IdentityContainer
         from .incident import Incident
@@ -108,6 +113,7 @@ class Security(Entity, Parsable):
             "alerts": lambda n : setattr(self, 'alerts', n.get_collection_of_object_values(Alert)),
             "alerts_v2": lambda n : setattr(self, 'alerts_v2', n.get_collection_of_object_values(Alert)),
             "attackSimulation": lambda n : setattr(self, 'attack_simulation', n.get_object_value(AttackSimulationRoot)),
+            "auditLog": lambda n : setattr(self, 'audit_log', n.get_object_value(AuditCoreRoot)),
             "cases": lambda n : setattr(self, 'cases', n.get_object_value(CasesRoot)),
             "dataSecurityAndGovernance": lambda n : setattr(self, 'data_security_and_governance', n.get_object_value(TenantDataSecurityAndGovernance)),
             "identities": lambda n : setattr(self, 'identities', n.get_object_value(IdentityContainer)),
@@ -136,6 +142,7 @@ class Security(Entity, Parsable):
         writer.write_collection_of_object_values("alerts", self.alerts)
         writer.write_collection_of_object_values("alerts_v2", self.alerts_v2)
         writer.write_object_value("attackSimulation", self.attack_simulation)
+        writer.write_object_value("auditLog", self.audit_log)
         writer.write_object_value("cases", self.cases)
         writer.write_object_value("dataSecurityAndGovernance", self.data_security_and_governance)
         writer.write_object_value("identities", self.identities)

msgraph/generated/models/security/security_compliance_alert_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 SecurityComplianceAlertRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.securityComplianceAlertRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SecurityComplianceAlertRecord:
+        """
+        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: SecurityComplianceAlertRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SecurityComplianceAlertRecord()
+    
+    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/security_compliance_center_e_o_p_cmdlet_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 SecurityComplianceCenterEOPCmdletAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.securityComplianceCenterEOPCmdletAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SecurityComplianceCenterEOPCmdletAuditRecord:
+        """
+        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: SecurityComplianceCenterEOPCmdletAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SecurityComplianceCenterEOPCmdletAuditRecord()
+    
+    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/security_compliance_insights_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 SecurityComplianceInsightsAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.securityComplianceInsightsAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SecurityComplianceInsightsAuditRecord:
+        """
+        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: SecurityComplianceInsightsAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SecurityComplianceInsightsAuditRecord()
+    
+    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/security_compliance_r_b_a_c_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 SecurityComplianceRBACAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.securityComplianceRBACAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SecurityComplianceRBACAuditRecord:
+        """
+        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: SecurityComplianceRBACAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SecurityComplianceRBACAuditRecord()
+    
+    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)
+    
+