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

msgraph/generated/models/security/threat_intelligence_mail_data.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 ThreatIntelligenceMailData(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.threatIntelligenceMailData"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> ThreatIntelligenceMailData:
-        """
-        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: ThreatIntelligenceMailData
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return ThreatIntelligenceMailData()
-    
-    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/threat_intelligence_url_click_data.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 ThreatIntelligenceUrlClickData(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.threatIntelligenceUrlClickData"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> ThreatIntelligenceUrlClickData:
-        """
-        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: ThreatIntelligenceUrlClickData
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return ThreatIntelligenceUrlClickData()
-    
-    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/todo_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 TodoAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.todoAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> TodoAuditRecord:
-        """
-        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: TodoAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return TodoAuditRecord()
-    
-    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/uam_operation_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 UamOperationAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.uamOperationAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> UamOperationAuditRecord:
-        """
-        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: UamOperationAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return UamOperationAuditRecord()
-    
-    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/unified_group_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 UnifiedGroupAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.unifiedGroupAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> UnifiedGroupAuditRecord:
-        """
-        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: UnifiedGroupAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return UnifiedGroupAuditRecord()
-    
-    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/unified_simulation_matched_item_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 UnifiedSimulationMatchedItemAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.unifiedSimulationMatchedItemAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> UnifiedSimulationMatchedItemAuditRecord:
-        """
-        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: UnifiedSimulationMatchedItemAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return UnifiedSimulationMatchedItemAuditRecord()
-    
-    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/unified_simulation_summary_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 UnifiedSimulationSummaryAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.unifiedSimulationSummaryAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> UnifiedSimulationSummaryAuditRecord:
-        """
-        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: UnifiedSimulationSummaryAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return UnifiedSimulationSummaryAuditRecord()
-    
-    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/upload_certificate_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 UploadCertificateRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.uploadCertificateRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> UploadCertificateRecord:
-        """
-        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: UploadCertificateRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return UploadCertificateRecord()
-    
-    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/urbac_assignment_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 UrbacAssignmentAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.urbacAssignmentAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> UrbacAssignmentAuditRecord:
-        """
-        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: UrbacAssignmentAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return UrbacAssignmentAuditRecord()
-    
-    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/urbac_enable_state_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 UrbacEnableStateAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.urbacEnableStateAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> UrbacEnableStateAuditRecord:
-        """
-        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: UrbacEnableStateAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return UrbacEnableStateAuditRecord()
-    
-    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/urbac_role_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 UrbacRoleAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.urbacRoleAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> UrbacRoleAuditRecord:
-        """
-        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: UrbacRoleAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return UrbacRoleAuditRecord()
-    
-    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/user_training_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 UserTrainingAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.userTrainingAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> UserTrainingAuditRecord:
-        """
-        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: UserTrainingAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return UserTrainingAuditRecord()
-    
-    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)
-    
-