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

msgraph/generated/models/security/aip_file_deleted.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 AipFileDeleted(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.aipFileDeleted"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> AipFileDeleted:
-        """
-        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: AipFileDeleted
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return AipFileDeleted()
-    
-    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/aip_heart_beat.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 AipHeartBeat(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.aipHeartBeat"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> AipHeartBeat:
-        """
-        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: AipHeartBeat
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return AipHeartBeat()
-    
-    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/aip_protection_action_log_request.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 AipProtectionActionLogRequest(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.aipProtectionActionLogRequest"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> AipProtectionActionLogRequest:
-        """
-        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: AipProtectionActionLogRequest
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return AipProtectionActionLogRequest()
-    
-    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/aip_scanner_discover_event.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 AipScannerDiscoverEvent(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.aipScannerDiscoverEvent"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> AipScannerDiscoverEvent:
-        """
-        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: AipScannerDiscoverEvent
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return AipScannerDiscoverEvent()
-    
-    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/aip_sensitivity_label_action_log_request.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 AipSensitivityLabelActionLogRequest(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.aipSensitivityLabelActionLogRequest"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> AipSensitivityLabelActionLogRequest:
-        """
-        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: AipSensitivityLabelActionLogRequest
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return AipSensitivityLabelActionLogRequest()
-    
-    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/air_admin_action_investigation_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 AirAdminActionInvestigationData(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.airAdminActionInvestigationData"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> AirAdminActionInvestigationData:
-        """
-        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: AirAdminActionInvestigationData
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return AirAdminActionInvestigationData()
-    
-    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/air_investigation_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 AirInvestigationData(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.airInvestigationData"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> AirInvestigationData:
-        """
-        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: AirInvestigationData
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return AirInvestigationData()
-    
-    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/air_manual_investigation_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 AirManualInvestigationData(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.airManualInvestigationData"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> AirManualInvestigationData:
-        """
-        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: AirManualInvestigationData
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return AirManualInvestigationData()
-    
-    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/attack_sim_admin_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 AttackSimAdminAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.attackSimAdminAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> AttackSimAdminAuditRecord:
-        """
-        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: AttackSimAdminAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return AttackSimAdminAuditRecord()
-    
-    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)
-    
-