msgraph-sdk 1.36.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

@@ -11,7 +11,9 @@ if TYPE_CHECKING:
     from ..secure_score import SecureScore
     from ..secure_score_control_profile import SecureScoreControlProfile
     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
@@ -30,8 +32,12 @@ 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
+    data_security_and_governance: Optional[TenantDataSecurityAndGovernance] = None
     # A container for security identities APIs.
     identities: Optional[IdentityContainer] = None
     # A collection of incidents in Microsoft 365 Defender, each of which is a set of correlated alerts and associated metadata that reflects the story of an attack.
@@ -75,7 +81,9 @@ class Security(Entity, Parsable):
         from ..secure_score import SecureScore
         from ..secure_score_control_profile import SecureScoreControlProfile
         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
@@ -90,7 +98,9 @@ class Security(Entity, Parsable):
         from ..secure_score import SecureScore
         from ..secure_score_control_profile import SecureScoreControlProfile
         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
@@ -103,7 +113,9 @@ 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)),
             "incidents": lambda n : setattr(self, 'incidents', n.get_collection_of_object_values(Incident)),
             "labels": lambda n : setattr(self, 'labels', n.get_object_value(LabelsRoot)),
@@ -130,7 +142,9 @@ 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)
         writer.write_collection_of_object_values("incidents", self.incidents)
         writer.write_object_value("labels", self.labels)

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