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

msgraph/generated/models/process_content_metadata_base.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+import datetime
+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 .content_base import ContentBase
+    from .process_conversation_metadata import ProcessConversationMetadata
+    from .process_file_metadata import ProcessFileMetadata
+
+@dataclass
+class ProcessContentMetadataBase(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)
+    # Represents the actual content, either as text (textContent) or binary data (binaryContent). Optional if metadata alone is sufficient for policy evaluation. Do not use for contentActivities.
+    content: Optional[ContentBase] = None
+    # An identifier used to group multiple related content entries (for example, different parts of the same file upload, messages in a conversation).
+    correlation_id: Optional[str] = None
+    # Required. Timestamp indicating when the original content was created (for example, file creation time, message sent time).
+    created_date_time: Optional[datetime.datetime] = None
+    # Required. A unique identifier for this specific content entry within the context of the calling application or enforcement plane (for example, message ID, file path/URL).
+    identifier: Optional[str] = None
+    # Required. Indicates if the provided content has been truncated from its original form (for example, due to size limits).
+    is_truncated: Optional[bool] = None
+    # The length of the original content in bytes.
+    length: Optional[int] = None
+    # Required. Timestamp indicating when the original content was last modified. For ephemeral content like messages, this might be the same as createdDateTime.
+    modified_date_time: Optional[datetime.datetime] = None
+    # Required. A descriptive name for the content (for example, file name, web page title, 'Chat Message').
+    name: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # A sequence number indicating the order in which content was generated or should be processed, required when correlationId is used.
+    sequence_number: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ProcessContentMetadataBase:
+        """
+        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: ProcessContentMetadataBase
+        """
+        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.processConversationMetadata".casefold():
+            from .process_conversation_metadata import ProcessConversationMetadata
+
+            return ProcessConversationMetadata()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.processFileMetadata".casefold():
+            from .process_file_metadata import ProcessFileMetadata
+
+            return ProcessFileMetadata()
+        return ProcessContentMetadataBase()
+    
+    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 .process_conversation_metadata import ProcessConversationMetadata
+        from .process_file_metadata import ProcessFileMetadata
+
+        from .content_base import ContentBase
+        from .process_conversation_metadata import ProcessConversationMetadata
+        from .process_file_metadata import ProcessFileMetadata
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "content": lambda n : setattr(self, 'content', n.get_object_value(ContentBase)),
+            "correlationId": lambda n : setattr(self, 'correlation_id', n.get_str_value()),
+            "createdDateTime": lambda n : setattr(self, 'created_date_time', n.get_datetime_value()),
+            "identifier": lambda n : setattr(self, 'identifier', n.get_str_value()),
+            "isTruncated": lambda n : setattr(self, 'is_truncated', n.get_bool_value()),
+            "length": lambda n : setattr(self, 'length', n.get_int_value()),
+            "modifiedDateTime": lambda n : setattr(self, 'modified_date_time', n.get_datetime_value()),
+            "name": lambda n : setattr(self, 'name', n.get_str_value()),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "sequenceNumber": lambda n : setattr(self, 'sequence_number', n.get_int_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_object_value("content", self.content)
+        writer.write_str_value("correlationId", self.correlation_id)
+        writer.write_datetime_value("createdDateTime", self.created_date_time)
+        writer.write_str_value("identifier", self.identifier)
+        writer.write_bool_value("isTruncated", self.is_truncated)
+        writer.write_int_value("length", self.length)
+        writer.write_datetime_value("modifiedDateTime", self.modified_date_time)
+        writer.write_str_value("name", self.name)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_int_value("sequenceNumber", self.sequence_number)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/process_content_request.py

@@ -0,0 +1,89 @@
+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 .activity_metadata import ActivityMetadata
+    from .device_metadata import DeviceMetadata
+    from .integrated_application_metadata import IntegratedApplicationMetadata
+    from .process_content_metadata_base import ProcessContentMetadataBase
+    from .protected_application_metadata import ProtectedApplicationMetadata
+
+@dataclass
+class ProcessContentRequest(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 activityMetadata property
+    activity_metadata: Optional[ActivityMetadata] = None
+    # A collection of content entries to be processed. Each entry contains the content itself and its metadata. Use conversation metadata for content like prompts and responses and file metadata for files. Required.
+    content_entries: Optional[list[ProcessContentMetadataBase]] = None
+    # The deviceMetadata property
+    device_metadata: Optional[DeviceMetadata] = None
+    # The integratedAppMetadata property
+    integrated_app_metadata: Optional[IntegratedApplicationMetadata] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # Metadata about the protected application making the request. Required.
+    protected_app_metadata: Optional[ProtectedApplicationMetadata] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ProcessContentRequest:
+        """
+        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: ProcessContentRequest
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ProcessContentRequest()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .activity_metadata import ActivityMetadata
+        from .device_metadata import DeviceMetadata
+        from .integrated_application_metadata import IntegratedApplicationMetadata
+        from .process_content_metadata_base import ProcessContentMetadataBase
+        from .protected_application_metadata import ProtectedApplicationMetadata
+
+        from .activity_metadata import ActivityMetadata
+        from .device_metadata import DeviceMetadata
+        from .integrated_application_metadata import IntegratedApplicationMetadata
+        from .process_content_metadata_base import ProcessContentMetadataBase
+        from .protected_application_metadata import ProtectedApplicationMetadata
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "activityMetadata": lambda n : setattr(self, 'activity_metadata', n.get_object_value(ActivityMetadata)),
+            "contentEntries": lambda n : setattr(self, 'content_entries', n.get_collection_of_object_values(ProcessContentMetadataBase)),
+            "deviceMetadata": lambda n : setattr(self, 'device_metadata', n.get_object_value(DeviceMetadata)),
+            "integratedAppMetadata": lambda n : setattr(self, 'integrated_app_metadata', n.get_object_value(IntegratedApplicationMetadata)),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "protectedAppMetadata": lambda n : setattr(self, 'protected_app_metadata', n.get_object_value(ProtectedApplicationMetadata)),
+        }
+        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_object_value("activityMetadata", self.activity_metadata)
+        writer.write_collection_of_object_values("contentEntries", self.content_entries)
+        writer.write_object_value("deviceMetadata", self.device_metadata)
+        writer.write_object_value("integratedAppMetadata", self.integrated_app_metadata)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_object_value("protectedAppMetadata", self.protected_app_metadata)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/process_content_response.py

@@ -0,0 +1,75 @@
+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_info import DlpActionInfo
+    from .processing_error import ProcessingError
+    from .protection_scope_state import ProtectionScopeState
+
+@dataclass
+class ProcessContentResponse(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
+    # A collection of policy actions (like DLP actions) triggered by the processed content. NOTE: Currently, the only policy action supported in for this resource type is restrictAccess.
+    policy_actions: Optional[list[DlpActionInfo]] = None
+    # A collection of errors encountered during the content processing.
+    processing_errors: Optional[list[ProcessingError]] = None
+    # The protectionScopeState property
+    protection_scope_state: Optional[ProtectionScopeState] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ProcessContentResponse:
+        """
+        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: ProcessContentResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ProcessContentResponse()
+    
+    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 .processing_error import ProcessingError
+        from .protection_scope_state import ProtectionScopeState
+
+        from .dlp_action_info import DlpActionInfo
+        from .processing_error import ProcessingError
+        from .protection_scope_state import ProtectionScopeState
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "policyActions": lambda n : setattr(self, 'policy_actions', n.get_collection_of_object_values(DlpActionInfo)),
+            "processingErrors": lambda n : setattr(self, 'processing_errors', n.get_collection_of_object_values(ProcessingError)),
+            "protectionScopeState": lambda n : setattr(self, 'protection_scope_state', n.get_enum_value(ProtectionScopeState)),
+        }
+        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_collection_of_object_values("policyActions", self.policy_actions)
+        writer.write_collection_of_object_values("processingErrors", self.processing_errors)
+        writer.write_enum_value("protectionScopeState", self.protection_scope_state)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/process_content_responses.py

@@ -0,0 +1,65 @@
+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 .process_content_response import ProcessContentResponse
+
+@dataclass
+class ProcessContentResponses(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
+    # The unique identifier that matches the requestId provided in the corresponding processContentBatchRequest.
+    request_id: Optional[str] = None
+    # The results property
+    results: Optional[ProcessContentResponse] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ProcessContentResponses:
+        """
+        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: ProcessContentResponses
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ProcessContentResponses()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .process_content_response import ProcessContentResponse
+
+        from .process_content_response import ProcessContentResponse
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "requestId": lambda n : setattr(self, 'request_id', n.get_str_value()),
+            "results": lambda n : setattr(self, 'results', n.get_object_value(ProcessContentResponse)),
+        }
+        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_str_value("requestId", self.request_id)
+        writer.write_object_value("results", self.results)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/process_conversation_metadata.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 .ai_interaction_plugin import AiInteractionPlugin
+    from .process_content_metadata_base import ProcessContentMetadataBase
+
+from .process_content_metadata_base import ProcessContentMetadataBase
+
+@dataclass
+class ProcessConversationMetadata(ProcessContentMetadataBase, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.processConversationMetadata"
+    # List of resources (for example, file URLs, web URLs) accessed during the generation of this message (relevant for bot interactions).
+    accessed_resources: Optional[list[str]] = None
+    # Identifier of the parent message in a threaded conversation, if applicable.
+    parent_message_id: Optional[str] = None
+    # List of plugins used during the generation of this message (relevant for AI/bot interactions).
+    plugins: Optional[list[AiInteractionPlugin]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ProcessConversationMetadata:
+        """
+        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: ProcessConversationMetadata
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ProcessConversationMetadata()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .ai_interaction_plugin import AiInteractionPlugin
+        from .process_content_metadata_base import ProcessContentMetadataBase
+
+        from .ai_interaction_plugin import AiInteractionPlugin
+        from .process_content_metadata_base import ProcessContentMetadataBase
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "accessedResources": lambda n : setattr(self, 'accessed_resources', n.get_collection_of_primitive_values(str)),
+            "parentMessageId": lambda n : setattr(self, 'parent_message_id', n.get_str_value()),
+            "plugins": lambda n : setattr(self, 'plugins', n.get_collection_of_object_values(AiInteractionPlugin)),
+        }
+        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_primitive_values("accessedResources", self.accessed_resources)
+        writer.write_str_value("parentMessageId", self.parent_message_id)
+        writer.write_collection_of_object_values("plugins", self.plugins)
+    
+

msgraph/generated/models/process_file_metadata.py

@@ -0,0 +1,64 @@
+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 .custom_metadata_dictionary import CustomMetadataDictionary
+    from .process_content_metadata_base import ProcessContentMetadataBase
+
+from .process_content_metadata_base import ProcessContentMetadataBase
+
+@dataclass
+class ProcessFileMetadata(ProcessContentMetadataBase, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.processFileMetadata"
+    # A dictionary containing custom metadata associated with the file, potentially extracted by the calling application.
+    custom_properties: Optional[CustomMetadataDictionary] = None
+    # The unique identifier (for example, Entra User ID or UPN) of the owner of the file.
+    owner_id: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ProcessFileMetadata:
+        """
+        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: ProcessFileMetadata
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ProcessFileMetadata()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .custom_metadata_dictionary import CustomMetadataDictionary
+        from .process_content_metadata_base import ProcessContentMetadataBase
+
+        from .custom_metadata_dictionary import CustomMetadataDictionary
+        from .process_content_metadata_base import ProcessContentMetadataBase
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "customProperties": lambda n : setattr(self, 'custom_properties', n.get_object_value(CustomMetadataDictionary)),
+            "ownerId": lambda n : setattr(self, 'owner_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("customProperties", self.custom_properties)
+        writer.write_str_value("ownerId", self.owner_id)
+    
+

msgraph/generated/models/processing_error.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 .classification_error import ClassificationError
+    from .content_processing_error_type import ContentProcessingErrorType
+
+from .classification_error import ClassificationError
+
+@dataclass
+class ProcessingError(ClassificationError, Parsable):
+    # The errorType property
+    error_type: Optional[ContentProcessingErrorType] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ProcessingError:
+        """
+        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: ProcessingError
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ProcessingError()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .classification_error import ClassificationError
+        from .content_processing_error_type import ContentProcessingErrorType
+
+        from .classification_error import ClassificationError
+        from .content_processing_error_type import ContentProcessingErrorType
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "errorType": lambda n : setattr(self, 'error_type', n.get_enum_value(ContentProcessingErrorType)),
+        }
+        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("errorType", self.error_type)
+    
+

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

@@ -0,0 +1,62 @@
+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
+
+@dataclass
+class ProtectedContent(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 content id
+    cid: Optional[str] = None
+    # The content format.
+    format: Optional[str] = None
+    # The unique identifier for the sensitivity label applied to the content.
+    label_id: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ProtectedContent:
+        """
+        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: ProtectedContent
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ProtectedContent()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        fields: dict[str, Callable[[Any], None]] = {
+            "cid": lambda n : setattr(self, 'cid', n.get_str_value()),
+            "format": lambda n : setattr(self, 'format', n.get_str_value()),
+            "labelId": lambda n : setattr(self, 'label_id', 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("cid", self.cid)
+        writer.write_str_value("format", self.format)
+        writer.write_str_value("labelId", self.label_id)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+