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

msgraph/generated/models/protection_scope_state.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class ProtectionScopeState(str, Enum):
+    NotModified = "notModified",
+    Modified = "modified",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/restrict_access_action.py

@@ -0,0 +1,53 @@
+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 .restrict_access_action_base import RestrictAccessActionBase
+
+from .restrict_access_action_base import RestrictAccessActionBase
+
+@dataclass
+class RestrictAccessAction(RestrictAccessActionBase, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.restrictAccessAction"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> RestrictAccessAction:
+        """
+        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: RestrictAccessAction
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return RestrictAccessAction()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .restrict_access_action_base import RestrictAccessActionBase
+
+        from .restrict_access_action_base import RestrictAccessActionBase
+
+        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/restrict_access_action_base.py

@@ -0,0 +1,72 @@
+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 .dlp_action_info import DlpActionInfo
+    from .restriction_action import RestrictionAction
+    from .restrict_access_action import RestrictAccessAction
+
+from .dlp_action_info import DlpActionInfo
+
+@dataclass
+class RestrictAccessActionBase(DlpActionInfo, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # Action for the app to take. The possible values are: warn, audit, block.
+    restriction_action: Optional[RestrictionAction] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> RestrictAccessActionBase:
+        """
+        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: RestrictAccessActionBase
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        try:
+            child_node = parse_node.get_child_node("@odata.type")
+            mapping_value = child_node.get_str_value() if child_node else None
+        except AttributeError:
+            mapping_value = None
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.restrictAccessAction".casefold():
+            from .restrict_access_action import RestrictAccessAction
+
+            return RestrictAccessAction()
+        return RestrictAccessActionBase()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .dlp_action_info import DlpActionInfo
+        from .restriction_action import RestrictionAction
+        from .restrict_access_action import RestrictAccessAction
+
+        from .dlp_action_info import DlpActionInfo
+        from .restriction_action import RestrictionAction
+        from .restrict_access_action import RestrictAccessAction
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "restrictionAction": lambda n : setattr(self, 'restriction_action', n.get_enum_value(RestrictionAction)),
+        }
+        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)
+        writer.write_enum_value("restrictionAction", self.restriction_action)
+    
+

msgraph/generated/models/restriction_action.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class RestrictionAction(str, Enum):
+    Warn = "warn",
+    Audit = "audit",
+    Block = "block",
+

msgraph/generated/models/scope_base.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from kiota_abstractions.store import BackedModel, BackingStore, BackingStoreFactorySingleton
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .group_scope import GroupScope
+    from .tenant_scope import TenantScope
+    from .user_scope import UserScope
+
+@dataclass
+class ScopeBase(AdditionalDataHolder, BackedModel, Parsable):
+    # Stores model information.
+    backing_store: BackingStore = field(default_factory=BackingStoreFactorySingleton(backing_store_factory=None).backing_store_factory.create_backing_store, repr=False)
+
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+    # The identifier for the scope. This could be a user ID, group ID, or a keyword like 'All' for tenant scope.
+    identity: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ScopeBase:
+        """
+        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: ScopeBase
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        try:
+            child_node = parse_node.get_child_node("@odata.type")
+            mapping_value = child_node.get_str_value() if child_node else None
+        except AttributeError:
+            mapping_value = None
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.groupScope".casefold():
+            from .group_scope import GroupScope
+
+            return GroupScope()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.tenantScope".casefold():
+            from .tenant_scope import TenantScope
+
+            return TenantScope()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.userScope".casefold():
+            from .user_scope import UserScope
+
+            return UserScope()
+        return ScopeBase()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .group_scope import GroupScope
+        from .tenant_scope import TenantScope
+        from .user_scope import UserScope
+
+        from .group_scope import GroupScope
+        from .tenant_scope import TenantScope
+        from .user_scope import UserScope
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "identity": lambda n : setattr(self, 'identity', n.get_str_value()),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+        }
+        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.")
+        writer.write_str_value("identity", self.identity)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/secure_sign_in_session_control.py

@@ -0,0 +1,53 @@
+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 .conditional_access_session_control import ConditionalAccessSessionControl
+
+from .conditional_access_session_control import ConditionalAccessSessionControl
+
+@dataclass
+class SecureSignInSessionControl(ConditionalAccessSessionControl, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.secureSignInSessionControl"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SecureSignInSessionControl:
+        """
+        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: SecureSignInSessionControl
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SecureSignInSessionControl()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .conditional_access_session_control import ConditionalAccessSessionControl
+
+        from .conditional_access_session_control import ConditionalAccessSessionControl
+
+        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/aad_risk_detection_audit_record.py

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

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

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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,53 @@
+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)
+    
+