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

msgraph/generated/models/content_activity.py

@@ -0,0 +1,68 @@
+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 .process_content_request import ProcessContentRequest
+
+from .entity import Entity
+
+@dataclass
+class ContentActivity(Entity, Parsable):
+    # The contentMetadata property
+    content_metadata: Optional[ProcessContentRequest] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The scope identified from computed protection scopes.
+    scope_identifier: Optional[str] = None
+    # ID of the user.
+    user_id: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ContentActivity:
+        """
+        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: ContentActivity
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ContentActivity()
+    
+    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 .process_content_request import ProcessContentRequest
+
+        from .entity import Entity
+        from .process_content_request import ProcessContentRequest
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "contentMetadata": lambda n : setattr(self, 'content_metadata', n.get_object_value(ProcessContentRequest)),
+            "scopeIdentifier": lambda n : setattr(self, 'scope_identifier', n.get_str_value()),
+            "userId": lambda n : setattr(self, 'user_id', 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_object_value("contentMetadata", self.content_metadata)
+        writer.write_str_value("scopeIdentifier", self.scope_identifier)
+        writer.write_str_value("userId", self.user_id)
+    
+

msgraph/generated/models/content_activity_collection_response.py

@@ -0,0 +1,58 @@
+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 .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+    from .content_activity import ContentActivity
+
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+
+@dataclass
+class ContentActivityCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[list[ContentActivity]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ContentActivityCollectionResponse:
+        """
+        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: ContentActivityCollectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ContentActivityCollectionResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .content_activity import ContentActivity
+
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .content_activity import ContentActivity
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(ContentActivity)),
+        }
+        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_collection_of_object_values("value", self.value)
+    
+

msgraph/generated/models/content_base.py

@@ -0,0 +1,73 @@
+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 .binary_content import BinaryContent
+    from .text_content import TextContent
+
+@dataclass
+class ContentBase(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 OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ContentBase:
+        """
+        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: ContentBase
+        """
+        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.binaryContent".casefold():
+            from .binary_content import BinaryContent
+
+            return BinaryContent()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.textContent".casefold():
+            from .text_content import TextContent
+
+            return TextContent()
+        return ContentBase()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .binary_content import BinaryContent
+        from .text_content import TextContent
+
+        from .binary_content import BinaryContent
+        from .text_content import TextContent
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "@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("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/content_processing_error_type.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class ContentProcessingErrorType(str, Enum):
+    Transient = "transient",
+    Permanent = "permanent",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/custom_metadata_dictionary.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 .dictionary import Dictionary
+
+from .dictionary import Dictionary
+
+@dataclass
+class CustomMetadataDictionary(Dictionary, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> CustomMetadataDictionary:
+        """
+        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: CustomMetadataDictionary
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return CustomMetadataDictionary()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .dictionary import Dictionary
+
+        from .dictionary import Dictionary
+
+        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/data_security_and_governance.py

@@ -0,0 +1,79 @@
+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 .sensitivity_label import SensitivityLabel
+    from .tenant_data_security_and_governance import TenantDataSecurityAndGovernance
+    from .user_data_security_and_governance import UserDataSecurityAndGovernance
+
+from .entity import Entity
+
+@dataclass
+class DataSecurityAndGovernance(Entity, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The sensitivityLabels property
+    sensitivity_labels: Optional[list[SensitivityLabel]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> DataSecurityAndGovernance:
+        """
+        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: DataSecurityAndGovernance
+        """
+        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.tenantDataSecurityAndGovernance".casefold():
+            from .tenant_data_security_and_governance import TenantDataSecurityAndGovernance
+
+            return TenantDataSecurityAndGovernance()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.userDataSecurityAndGovernance".casefold():
+            from .user_data_security_and_governance import UserDataSecurityAndGovernance
+
+            return UserDataSecurityAndGovernance()
+        return DataSecurityAndGovernance()
+    
+    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 .sensitivity_label import SensitivityLabel
+        from .tenant_data_security_and_governance import TenantDataSecurityAndGovernance
+        from .user_data_security_and_governance import UserDataSecurityAndGovernance
+
+        from .entity import Entity
+        from .sensitivity_label import SensitivityLabel
+        from .tenant_data_security_and_governance import TenantDataSecurityAndGovernance
+        from .user_data_security_and_governance import UserDataSecurityAndGovernance
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "sensitivityLabels": lambda n : setattr(self, 'sensitivity_labels', n.get_collection_of_object_values(SensitivityLabel)),
+        }
+        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_collection_of_object_values("sensitivityLabels", self.sensitivity_labels)
+    
+

msgraph/generated/models/device_metadata.py

@@ -0,0 +1,69 @@
+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 .operating_system_specifications import OperatingSystemSpecifications
+
+@dataclass
+class DeviceMetadata(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)
+    # Optional. The general type of the device (for example, 'Managed', 'Unmanaged').
+    device_type: Optional[str] = None
+    # The Internet Protocol (IP) address of the device.
+    ip_address: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # Details about the operating system platform and version.
+    operating_system_specifications: Optional[OperatingSystemSpecifications] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> DeviceMetadata:
+        """
+        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: DeviceMetadata
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return DeviceMetadata()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .operating_system_specifications import OperatingSystemSpecifications
+
+        from .operating_system_specifications import OperatingSystemSpecifications
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "deviceType": lambda n : setattr(self, 'device_type', n.get_str_value()),
+            "ipAddress": lambda n : setattr(self, 'ip_address', n.get_str_value()),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "operatingSystemSpecifications": lambda n : setattr(self, 'operating_system_specifications', n.get_object_value(OperatingSystemSpecifications)),
+        }
+        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("deviceType", self.device_type)
+        writer.write_str_value("ipAddress", self.ip_address)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_object_value("operatingSystemSpecifications", self.operating_system_specifications)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/dictionary.py

@@ -6,6 +6,7 @@ from kiota_abstractions.store import BackedModel, BackingStore, BackingStoreFact
 from typing import Any, Optional, TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
+    from .custom_metadata_dictionary import CustomMetadataDictionary
     from .file_storage_container_custom_property_dictionary import FileStorageContainerCustomPropertyDictionary
     from .result_template_dictionary import ResultTemplateDictionary
 
@@ -33,6 +34,10 @@ class Dictionary(AdditionalDataHolder, BackedModel, Parsable):
             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.customMetadataDictionary".casefold():
+            from .custom_metadata_dictionary import CustomMetadataDictionary
+
+            return CustomMetadataDictionary()
         if mapping_value and mapping_value.casefold() == "#microsoft.graph.fileStorageContainerCustomPropertyDictionary".casefold():
             from .file_storage_container_custom_property_dictionary import FileStorageContainerCustomPropertyDictionary
 
@@ -48,9 +53,11 @@ class Dictionary(AdditionalDataHolder, BackedModel, Parsable):
         The deserialization information for the current model
         Returns: dict[str, Callable[[ParseNode], None]]
         """
+        from .custom_metadata_dictionary import CustomMetadataDictionary
         from .file_storage_container_custom_property_dictionary import FileStorageContainerCustomPropertyDictionary
         from .result_template_dictionary import ResultTemplateDictionary
 
+        from .custom_metadata_dictionary import CustomMetadataDictionary
         from .file_storage_container_custom_property_dictionary import FileStorageContainerCustomPropertyDictionary
         from .result_template_dictionary import ResultTemplateDictionary
 

msgraph/generated/models/dlp_action.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+class DlpAction(str, Enum):
+    NotifyUser = "notifyUser",
+    BlockAccess = "blockAccess",
+    DeviceRestriction = "deviceRestriction",
+    BrowserRestriction = "browserRestriction",
+    UnknownFutureValue = "unknownFutureValue",
+    RestrictAccess = "restrictAccess",
+    GenerateAlert = "generateAlert",
+    GenerateIncidentReportAction = "generateIncidentReportAction",
+    SPBlockAnonymousAccess = "sPBlockAnonymousAccess",
+    SPRuntimeAccessControl = "sPRuntimeAccessControl",
+    SPSharingNotifyUser = "sPSharingNotifyUser",
+    SPSharingGenerateIncidentReport = "sPSharingGenerateIncidentReport",
+

msgraph/generated/models/dlp_action_info.py

@@ -0,0 +1,80 @@
+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 .dlp_action import DlpAction
+    from .restrict_access_action import RestrictAccessAction
+    from .restrict_access_action_base import RestrictAccessActionBase
+
+@dataclass
+class DlpActionInfo(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 type of DLP action. Possible value is restrictAccessAction.
+    action: Optional[DlpAction] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> DlpActionInfo:
+        """
+        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: DlpActionInfo
+        """
+        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()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.restrictAccessActionBase".casefold():
+            from .restrict_access_action_base import RestrictAccessActionBase
+
+            return RestrictAccessActionBase()
+        return DlpActionInfo()
+    
+    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 import DlpAction
+        from .restrict_access_action import RestrictAccessAction
+        from .restrict_access_action_base import RestrictAccessActionBase
+
+        from .dlp_action import DlpAction
+        from .restrict_access_action import RestrictAccessAction
+        from .restrict_access_action_base import RestrictAccessActionBase
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "action": lambda n : setattr(self, 'action', n.get_enum_value(DlpAction)),
+            "@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_enum_value("action", self.action)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/drive_recipient.py

@@ -12,7 +12,7 @@ class DriveRecipient(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 alias of the domain object, for cases where an email address is unavailable (e.g. security groups).
+    # The alias of the domain object, for cases where an email address is unavailable (for example, security groups).
     alias: Optional[str] = None
     # The email address for the recipient, if the recipient has an associated email address.
     email: Optional[str] = None