msgraph-sdk 1.35.0__py3-none-any.whl → 1.37.0__py3-none-any.whl

msgraph/generated/models/protected_application_metadata.py

@@ -0,0 +1,60 @@
+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 .integrated_application_metadata import IntegratedApplicationMetadata
+    from .policy_location import PolicyLocation
+
+from .integrated_application_metadata import IntegratedApplicationMetadata
+
+@dataclass
+class ProtectedApplicationMetadata(IntegratedApplicationMetadata, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.protectedApplicationMetadata"
+    # The client (application) ID of the Microsoft Entra application. Required.
+    application_location: Optional[PolicyLocation] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ProtectedApplicationMetadata:
+        """
+        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: ProtectedApplicationMetadata
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ProtectedApplicationMetadata()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .integrated_application_metadata import IntegratedApplicationMetadata
+        from .policy_location import PolicyLocation
+
+        from .integrated_application_metadata import IntegratedApplicationMetadata
+        from .policy_location import PolicyLocation
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "applicationLocation": lambda n : setattr(self, 'application_location', n.get_object_value(PolicyLocation)),
+        }
+        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_object_value("applicationLocation", self.application_location)
+    
+

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/public_key_infrastructure_root.py

@@ -12,7 +12,7 @@ from .entity import Entity
 
 @dataclass
 class PublicKeyInfrastructureRoot(Entity, Parsable):
-    # The certificateBasedAuthConfigurations property
+    # The collection of public key infrastructure instances for the certificate-based authentication feature for users.
     certificate_based_auth_configurations: Optional[list[CertificateBasedAuthPki]] = None
     # The OdataType property
     odata_type: Optional[str] = None

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/security/security.py

@@ -11,6 +11,7 @@ if TYPE_CHECKING:
     from ..secure_score import SecureScore
     from ..secure_score_control_profile import SecureScoreControlProfile
     from ..subject_rights_request import SubjectRightsRequest
+    from ..tenant_data_security_and_governance import TenantDataSecurityAndGovernance
     from .alert import Alert
     from .cases_root import CasesRoot
     from .identity_container import IdentityContainer
@@ -32,6 +33,8 @@ class Security(Entity, Parsable):
     attack_simulation: Optional[AttackSimulationRoot] = None
     # The cases property
     cases: Optional[CasesRoot] = None
+    # The dataSecurityAndGovernance property
+    data_security_and_governance: Optional[TenantDataSecurityAndGovernance] = None
     # A container for security identities APIs.
     identities: Optional[IdentityContainer] = None
     # A collection of incidents in Microsoft 365 Defender, each of which is a set of correlated alerts and associated metadata that reflects the story of an attack.
@@ -75,6 +78,7 @@ class Security(Entity, Parsable):
         from ..secure_score import SecureScore
         from ..secure_score_control_profile import SecureScoreControlProfile
         from ..subject_rights_request import SubjectRightsRequest
+        from ..tenant_data_security_and_governance import TenantDataSecurityAndGovernance
         from .alert import Alert
         from .cases_root import CasesRoot
         from .identity_container import IdentityContainer
@@ -90,6 +94,7 @@ class Security(Entity, Parsable):
         from ..secure_score import SecureScore
         from ..secure_score_control_profile import SecureScoreControlProfile
         from ..subject_rights_request import SubjectRightsRequest
+        from ..tenant_data_security_and_governance import TenantDataSecurityAndGovernance
         from .alert import Alert
         from .cases_root import CasesRoot
         from .identity_container import IdentityContainer
@@ -104,6 +109,7 @@ class Security(Entity, Parsable):
             "alerts_v2": lambda n : setattr(self, 'alerts_v2', n.get_collection_of_object_values(Alert)),
             "attackSimulation": lambda n : setattr(self, 'attack_simulation', n.get_object_value(AttackSimulationRoot)),
             "cases": lambda n : setattr(self, 'cases', n.get_object_value(CasesRoot)),
+            "dataSecurityAndGovernance": lambda n : setattr(self, 'data_security_and_governance', n.get_object_value(TenantDataSecurityAndGovernance)),
             "identities": lambda n : setattr(self, 'identities', n.get_object_value(IdentityContainer)),
             "incidents": lambda n : setattr(self, 'incidents', n.get_collection_of_object_values(Incident)),
             "labels": lambda n : setattr(self, 'labels', n.get_object_value(LabelsRoot)),
@@ -131,6 +137,7 @@ class Security(Entity, Parsable):
         writer.write_collection_of_object_values("alerts_v2", self.alerts_v2)
         writer.write_object_value("attackSimulation", self.attack_simulation)
         writer.write_object_value("cases", self.cases)
+        writer.write_object_value("dataSecurityAndGovernance", self.data_security_and_governance)
         writer.write_object_value("identities", self.identities)
         writer.write_collection_of_object_values("incidents", self.incidents)
         writer.write_object_value("labels", self.labels)

msgraph/generated/models/tenant_data_security_and_governance.py

@@ -0,0 +1,60 @@
+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 .data_security_and_governance import DataSecurityAndGovernance
+    from .tenant_protection_scope_container import TenantProtectionScopeContainer
+
+from .data_security_and_governance import DataSecurityAndGovernance
+
+@dataclass
+class TenantDataSecurityAndGovernance(DataSecurityAndGovernance, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.tenantDataSecurityAndGovernance"
+    # The protectionScopes property
+    protection_scopes: Optional[TenantProtectionScopeContainer] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> TenantDataSecurityAndGovernance:
+        """
+        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: TenantDataSecurityAndGovernance
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return TenantDataSecurityAndGovernance()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .data_security_and_governance import DataSecurityAndGovernance
+        from .tenant_protection_scope_container import TenantProtectionScopeContainer
+
+        from .data_security_and_governance import DataSecurityAndGovernance
+        from .tenant_protection_scope_container import TenantProtectionScopeContainer
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "protectionScopes": lambda n : setattr(self, 'protection_scopes', n.get_object_value(TenantProtectionScopeContainer)),
+        }
+        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_object_value("protectionScopes", self.protection_scopes)
+    
+

msgraph/generated/models/tenant_protection_scope_container.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 .entity import Entity
+
+from .entity import Entity
+
+@dataclass
+class TenantProtectionScopeContainer(Entity, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> TenantProtectionScopeContainer:
+        """
+        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: TenantProtectionScopeContainer
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return TenantProtectionScopeContainer()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .entity import Entity
+
+        from .entity import Entity
+
+        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/tenant_scope.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 .scope_base import ScopeBase
+
+from .scope_base import ScopeBase
+
+@dataclass
+class TenantScope(ScopeBase, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.tenantScope"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> TenantScope:
+        """
+        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: TenantScope
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return TenantScope()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .scope_base import ScopeBase
+
+        from .scope_base import ScopeBase
+
+        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/text_content.py

@@ -0,0 +1,57 @@
+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 .content_base import ContentBase
+
+from .content_base import ContentBase
+
+@dataclass
+class TextContent(ContentBase, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.textContent"
+    # The text content data. Inherits properties from contentBase.
+    data: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> TextContent:
+        """
+        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: TextContent
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return TextContent()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .content_base import ContentBase
+
+        from .content_base import ContentBase
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "data": lambda n : setattr(self, 'data', n.get_str_value()),
+        }
+        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_str_value("data", self.data)
+    
+

msgraph/generated/models/upload_session.py

@@ -13,7 +13,7 @@ class UploadSession(AdditionalDataHolder, BackedModel, Parsable):
 
     # 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 date and time in UTC that the upload session will expire. The complete file must be uploaded before this expiration time is reached.
+    # The date and time in UTC that the upload session expires. The complete file must be uploaded before this expiration time is reached. Each fragment uploaded during the session extends the expiration time.
     expiration_date_time: Optional[datetime.datetime] = None
     # A collection of byte ranges that the server is missing for the file. These ranges are zero indexed and of the format 'start-end' (for example '0-26' to indicate the first 27 bytes of the file). When uploading files as Outlook attachments, instead of a collection of ranges, this property always indicates a single value '{start}', the location in the file where the next upload should begin.
     next_expected_ranges: Optional[list[str]] = None

msgraph/generated/models/usage_rights.py

@@ -0,0 +1,25 @@
+from enum import Enum
+
+class UsageRights(str, Enum):
+    Unknown = "unknown",
+    DocEdit = "docEdit",
+    Edit = "edit",
+    Comment = "comment",
+    Export = "export",
+    Forward = "forward",
+    Owner = "owner",
+    Print = "print",
+    Reply = "reply",
+    ReplyAll = "replyAll",
+    View = "view",
+    Extract = "extract",
+    ViewRightsData = "viewRightsData",
+    EditRightsData = "editRightsData",
+    ObjModel = "objModel",
+    AccessDenied = "accessDenied",
+    UserDefinedProtectionTypeNotSupportedException = "userDefinedProtectionTypeNotSupportedException",
+    EncryptedProtectionTypeNotSupportedException = "encryptedProtectionTypeNotSupportedException",
+    PurviewClaimsChallengeNotSupportedException = "purviewClaimsChallengeNotSupportedException",
+    Exception = "exception",
+    UnknownFutureValue = "unknownFutureValue",
+