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

msgraph/generated/models/security/microsoft_teams_device_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 MicrosoftTeamsDeviceAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.microsoftTeamsDeviceAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> MicrosoftTeamsDeviceAuditRecord:
+        """
+        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: MicrosoftTeamsDeviceAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return MicrosoftTeamsDeviceAuditRecord()
+    
+    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/microsoft_teams_retention_label_action_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 MicrosoftTeamsRetentionLabelActionAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.microsoftTeamsRetentionLabelActionAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> MicrosoftTeamsRetentionLabelActionAuditRecord:
+        """
+        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: MicrosoftTeamsRetentionLabelActionAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return MicrosoftTeamsRetentionLabelActionAuditRecord()
+    
+    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/microsoft_teams_sensitivity_label_action_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 MicrosoftTeamsSensitivityLabelActionAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.microsoftTeamsSensitivityLabelActionAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> MicrosoftTeamsSensitivityLabelActionAuditRecord:
+        """
+        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: MicrosoftTeamsSensitivityLabelActionAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return MicrosoftTeamsSensitivityLabelActionAuditRecord()
+    
+    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/microsoft_teams_shifts_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 MicrosoftTeamsShiftsAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.microsoftTeamsShiftsAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> MicrosoftTeamsShiftsAuditRecord:
+        """
+        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: MicrosoftTeamsShiftsAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return MicrosoftTeamsShiftsAuditRecord()
+    
+    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/mip_auto_label_exchange_item_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 MipAutoLabelExchangeItemAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.mipAutoLabelExchangeItemAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> MipAutoLabelExchangeItemAuditRecord:
+        """
+        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: MipAutoLabelExchangeItemAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return MipAutoLabelExchangeItemAuditRecord()
+    
+    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/mip_auto_label_item_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 MipAutoLabelItemAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.mipAutoLabelItemAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> MipAutoLabelItemAuditRecord:
+        """
+        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: MipAutoLabelItemAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return MipAutoLabelItemAuditRecord()
+    
+    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/mip_auto_label_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 MipAutoLabelPolicyAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.mipAutoLabelPolicyAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> MipAutoLabelPolicyAuditRecord:
+        """
+        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: MipAutoLabelPolicyAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return MipAutoLabelPolicyAuditRecord()
+    
+    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/mip_auto_label_progress_feedback_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 MipAutoLabelProgressFeedbackAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.mipAutoLabelProgressFeedbackAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> MipAutoLabelProgressFeedbackAuditRecord:
+        """
+        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: MipAutoLabelProgressFeedbackAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return MipAutoLabelProgressFeedbackAuditRecord()
+    
+    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/mip_auto_label_share_point_item_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 MipAutoLabelSharePointItemAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.mipAutoLabelSharePointItemAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> MipAutoLabelSharePointItemAuditRecord:
+        """
+        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: MipAutoLabelSharePointItemAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return MipAutoLabelSharePointItemAuditRecord()
+    
+    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/mip_auto_label_share_point_policy_location_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 MipAutoLabelSharePointPolicyLocationAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.mipAutoLabelSharePointPolicyLocationAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> MipAutoLabelSharePointPolicyLocationAuditRecord:
+        """
+        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: MipAutoLabelSharePointPolicyLocationAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return MipAutoLabelSharePointPolicyLocationAuditRecord()
+    
+    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/mip_auto_label_simulation_share_point_completion_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 MipAutoLabelSimulationSharePointCompletionRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.mipAutoLabelSimulationSharePointCompletionRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> MipAutoLabelSimulationSharePointCompletionRecord:
+        """
+        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: MipAutoLabelSimulationSharePointCompletionRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return MipAutoLabelSimulationSharePointCompletionRecord()
+    
+    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/mip_auto_label_simulation_share_point_progress_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 MipAutoLabelSimulationSharePointProgressRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.mipAutoLabelSimulationSharePointProgressRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> MipAutoLabelSimulationSharePointProgressRecord:
+        """
+        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: MipAutoLabelSimulationSharePointProgressRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return MipAutoLabelSimulationSharePointProgressRecord()
+    
+    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)
+    
+