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

msgraph/generated/models/security/vfam_base_policy_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 VfamBasePolicyAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.vfamBasePolicyAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> VfamBasePolicyAuditRecord:
-        """
-        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: VfamBasePolicyAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return VfamBasePolicyAuditRecord()
-    
-    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/vfam_create_policy_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 VfamCreatePolicyAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.vfamCreatePolicyAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> VfamCreatePolicyAuditRecord:
-        """
-        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: VfamCreatePolicyAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return VfamCreatePolicyAuditRecord()
-    
-    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/vfam_delete_policy_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 VfamDeletePolicyAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.vfamDeletePolicyAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> VfamDeletePolicyAuditRecord:
-        """
-        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: VfamDeletePolicyAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return VfamDeletePolicyAuditRecord()
-    
-    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/vfam_update_policy_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 VfamUpdatePolicyAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.vfamUpdatePolicyAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> VfamUpdatePolicyAuditRecord:
-        """
-        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: VfamUpdatePolicyAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return VfamUpdatePolicyAuditRecord()
-    
-    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/viva_goals_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 VivaGoalsAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.vivaGoalsAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> VivaGoalsAuditRecord:
-        """
-        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: VivaGoalsAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return VivaGoalsAuditRecord()
-    
-    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/viva_learning_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 VivaLearningAdminAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.vivaLearningAdminAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> VivaLearningAdminAuditRecord:
-        """
-        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: VivaLearningAdminAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return VivaLearningAdminAuditRecord()
-    
-    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/viva_learning_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 VivaLearningAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.vivaLearningAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> VivaLearningAuditRecord:
-        """
-        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: VivaLearningAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return VivaLearningAuditRecord()
-    
-    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/viva_pulse_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 VivaPulseAdminAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.vivaPulseAdminAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> VivaPulseAdminAuditRecord:
-        """
-        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: VivaPulseAdminAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return VivaPulseAdminAuditRecord()
-    
-    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/viva_pulse_organizer_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 VivaPulseOrganizerAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.vivaPulseOrganizerAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> VivaPulseOrganizerAuditRecord:
-        """
-        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: VivaPulseOrganizerAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return VivaPulseOrganizerAuditRecord()
-    
-    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/viva_pulse_report_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 VivaPulseReportAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.vivaPulseReportAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> VivaPulseReportAuditRecord:
-        """
-        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: VivaPulseReportAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return VivaPulseReportAuditRecord()
-    
-    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/viva_pulse_response_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 VivaPulseResponseAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.vivaPulseResponseAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> VivaPulseResponseAuditRecord:
-        """
-        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: VivaPulseResponseAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return VivaPulseResponseAuditRecord()
-    
-    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/wdatp_alerts_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 WdatpAlertsAuditRecord(AuditData, Parsable):
-    # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.wdatpAlertsAuditRecord"
-    
-    @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> WdatpAlertsAuditRecord:
-        """
-        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: WdatpAlertsAuditRecord
-        """
-        if parse_node is None:
-            raise TypeError("parse_node cannot be null.")
-        return WdatpAlertsAuditRecord()
-    
-    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)
-    
-