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

msgraph/generated/models/security/irm_security_alert_record.py

@@ -1,53 +0,0 @@
-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 IrmSecurityAlertRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.irmSecurityAlertRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> IrmSecurityAlertRecord:
-        """
-        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: IrmSecurityAlertRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return IrmSecurityAlertRecord()
-    
-    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/irm_user_defined_detection_record.py

@@ -1,53 +0,0 @@
-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 IrmUserDefinedDetectionRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.irmUserDefinedDetectionRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> IrmUserDefinedDetectionRecord:
-        """
-        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: IrmUserDefinedDetectionRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return IrmUserDefinedDetectionRecord()
-    
-    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/kaizala_audit_record.py

@@ -1,53 +0,0 @@
-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 KaizalaAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.kaizalaAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> KaizalaAuditRecord:
-        """
-        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: KaizalaAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return KaizalaAuditRecord()
-    
-    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/label_analytics_aggregate_audit_record.py

@@ -1,53 +0,0 @@
-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 LabelAnalyticsAggregateAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.labelAnalyticsAggregateAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> LabelAnalyticsAggregateAuditRecord:
-        """
-        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: LabelAnalyticsAggregateAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return LabelAnalyticsAggregateAuditRecord()
-    
-    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/label_content_explorer_audit_record.py

@@ -1,53 +0,0 @@
-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 LabelContentExplorerAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.labelContentExplorerAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> LabelContentExplorerAuditRecord:
-        """
-        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: LabelContentExplorerAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return LabelContentExplorerAuditRecord()
-    
-    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/large_content_metadata_audit_record.py

@@ -1,53 +0,0 @@
-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 LargeContentMetadataAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.largeContentMetadataAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> LargeContentMetadataAuditRecord:
-        """
-        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: LargeContentMetadataAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return LargeContentMetadataAuditRecord()
-    
-    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/m365_compliance_connector_audit_record.py

@@ -1,53 +0,0 @@
-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 M365ComplianceConnectorAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.m365ComplianceConnectorAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> M365ComplianceConnectorAuditRecord:
-        """
-        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: M365ComplianceConnectorAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return M365ComplianceConnectorAuditRecord()
-    
-    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/m365_d_a_a_d_audit_record.py

@@ -1,53 +0,0 @@
-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 M365DAADAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.m365DAADAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> M365DAADAuditRecord:
-        """
-        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: M365DAADAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return M365DAADAuditRecord()
-    
-    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/m_s365_d_custom_detection_audit_record.py

@@ -1,53 +0,0 @@
-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 MS365DCustomDetectionAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.mS365DCustomDetectionAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> MS365DCustomDetectionAuditRecord:
-        """
-        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: MS365DCustomDetectionAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return MS365DCustomDetectionAuditRecord()
-    
-    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/m_s365_d_incident_audit_record.py

@@ -1,53 +0,0 @@
-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 MS365DIncidentAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.mS365DIncidentAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> MS365DIncidentAuditRecord:
-        """
-        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: MS365DIncidentAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return MS365DIncidentAuditRecord()
-    
-    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/m_s365_d_suppression_rule_audit_record.py

@@ -1,53 +0,0 @@
-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 MS365DSuppressionRuleAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.mS365DSuppressionRuleAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> MS365DSuppressionRuleAuditRecord:
-        """
-        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: MS365DSuppressionRuleAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return MS365DSuppressionRuleAuditRecord()
-    
-    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/managed_services_audit_record.py

@@ -1,53 +0,0 @@
-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 ManagedServicesAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.managedServicesAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> ManagedServicesAuditRecord:
-        """
-        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: ManagedServicesAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return ManagedServicesAuditRecord()
-    
-    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)
-    
-