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

msgraph/generated/models/security/microsoft365_backup_restore_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 Microsoft365BackupRestoreItemAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.microsoft365BackupRestoreItemAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> Microsoft365BackupRestoreItemAuditRecord:
-        """
-        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: Microsoft365BackupRestoreItemAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return Microsoft365BackupRestoreItemAuditRecord()
-    
-    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/microsoft365_backup_restore_task_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 Microsoft365BackupRestoreTaskAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.microsoft365BackupRestoreTaskAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> Microsoft365BackupRestoreTaskAuditRecord:
-        """
-        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: Microsoft365BackupRestoreTaskAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return Microsoft365BackupRestoreTaskAuditRecord()
-    
-    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_defender_experts_base_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 MicrosoftDefenderExpertsBaseAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.microsoftDefenderExpertsBaseAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> MicrosoftDefenderExpertsBaseAuditRecord:
-        """
-        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: MicrosoftDefenderExpertsBaseAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return MicrosoftDefenderExpertsBaseAuditRecord()
-    
-    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_defender_experts_x_d_r_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 MicrosoftDefenderExpertsXDRAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.microsoftDefenderExpertsXDRAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> MicrosoftDefenderExpertsXDRAuditRecord:
-        """
-        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: MicrosoftDefenderExpertsXDRAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return MicrosoftDefenderExpertsXDRAuditRecord()
-    
-    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_flow_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 MicrosoftFlowAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.microsoftFlowAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> MicrosoftFlowAuditRecord:
-        """
-        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: MicrosoftFlowAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return MicrosoftFlowAuditRecord()
-    
-    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_forms_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 MicrosoftFormsAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.microsoftFormsAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> MicrosoftFormsAuditRecord:
-        """
-        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: MicrosoftFormsAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return MicrosoftFormsAuditRecord()
-    
-    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_graph_data_connect_consent.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 MicrosoftGraphDataConnectConsent(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.microsoftGraphDataConnectConsent"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> MicrosoftGraphDataConnectConsent:
-        """
-        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: MicrosoftGraphDataConnectConsent
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return MicrosoftGraphDataConnectConsent()
-    
-    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_graph_data_connect_operation.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 MicrosoftGraphDataConnectOperation(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.microsoftGraphDataConnectOperation"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> MicrosoftGraphDataConnectOperation:
-        """
-        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: MicrosoftGraphDataConnectOperation
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return MicrosoftGraphDataConnectOperation()
-    
-    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_purview_data_map_operation_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 MicrosoftPurviewDataMapOperationRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.microsoftPurviewDataMapOperationRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> MicrosoftPurviewDataMapOperationRecord:
-        """
-        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: MicrosoftPurviewDataMapOperationRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return MicrosoftPurviewDataMapOperationRecord()
-    
-    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_purview_policy_operation_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 MicrosoftPurviewPolicyOperationRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.microsoftPurviewPolicyOperationRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> MicrosoftPurviewPolicyOperationRecord:
-        """
-        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: MicrosoftPurviewPolicyOperationRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return MicrosoftPurviewPolicyOperationRecord()
-    
-    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_purview_privacy_audit_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 MicrosoftPurviewPrivacyAuditEvent(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.microsoftPurviewPrivacyAuditEvent"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> MicrosoftPurviewPrivacyAuditEvent:
-        """
-        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: MicrosoftPurviewPrivacyAuditEvent
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return MicrosoftPurviewPrivacyAuditEvent()
-    
-    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_stream_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 MicrosoftStreamAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.microsoftStreamAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> MicrosoftStreamAuditRecord:
-        """
-        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: MicrosoftStreamAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return MicrosoftStreamAuditRecord()
-    
-    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)
-    
-