msgraph-sdk 1.30.0__py3-none-any.whl → 1.31.0__py3-none-any.whl

msgraph/generated/models/ai_interaction.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+import datetime
+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_attachment import AiInteractionAttachment
+    from .ai_interaction_context import AiInteractionContext
+    from .ai_interaction_link import AiInteractionLink
+    from .ai_interaction_mention import AiInteractionMention
+    from .ai_interaction_type import AiInteractionType
+    from .entity import Entity
+    from .identity_set import IdentitySet
+    from .item_body import ItemBody
+
+from .entity import Entity
+
+@dataclass
+class AiInteraction(Entity, Parsable):
+    # The appClass property
+    app_class: Optional[str] = None
+    # The attachments property
+    attachments: Optional[list[AiInteractionAttachment]] = None
+    # The body property
+    body: Optional[ItemBody] = None
+    # The contexts property
+    contexts: Optional[list[AiInteractionContext]] = None
+    # The conversationType property
+    conversation_type: Optional[str] = None
+    # The createdDateTime property
+    created_date_time: Optional[datetime.datetime] = None
+    # The etag property
+    etag: Optional[str] = None
+    # The from property
+    from_: Optional[IdentitySet] = None
+    # The interactionType property
+    interaction_type: Optional[AiInteractionType] = None
+    # The links property
+    links: Optional[list[AiInteractionLink]] = None
+    # The locale property
+    locale: Optional[str] = None
+    # The mentions property
+    mentions: Optional[list[AiInteractionMention]] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The requestId property
+    request_id: Optional[str] = None
+    # The sessionId property
+    session_id: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AiInteraction:
+        """
+        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: AiInteraction
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AiInteraction()
+    
+    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_attachment import AiInteractionAttachment
+        from .ai_interaction_context import AiInteractionContext
+        from .ai_interaction_link import AiInteractionLink
+        from .ai_interaction_mention import AiInteractionMention
+        from .ai_interaction_type import AiInteractionType
+        from .entity import Entity
+        from .identity_set import IdentitySet
+        from .item_body import ItemBody
+
+        from .ai_interaction_attachment import AiInteractionAttachment
+        from .ai_interaction_context import AiInteractionContext
+        from .ai_interaction_link import AiInteractionLink
+        from .ai_interaction_mention import AiInteractionMention
+        from .ai_interaction_type import AiInteractionType
+        from .entity import Entity
+        from .identity_set import IdentitySet
+        from .item_body import ItemBody
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "appClass": lambda n : setattr(self, 'app_class', n.get_str_value()),
+            "attachments": lambda n : setattr(self, 'attachments', n.get_collection_of_object_values(AiInteractionAttachment)),
+            "body": lambda n : setattr(self, 'body', n.get_object_value(ItemBody)),
+            "contexts": lambda n : setattr(self, 'contexts', n.get_collection_of_object_values(AiInteractionContext)),
+            "conversationType": lambda n : setattr(self, 'conversation_type', n.get_str_value()),
+            "createdDateTime": lambda n : setattr(self, 'created_date_time', n.get_datetime_value()),
+            "etag": lambda n : setattr(self, 'etag', n.get_str_value()),
+            "from": lambda n : setattr(self, 'from_', n.get_object_value(IdentitySet)),
+            "interactionType": lambda n : setattr(self, 'interaction_type', n.get_enum_value(AiInteractionType)),
+            "links": lambda n : setattr(self, 'links', n.get_collection_of_object_values(AiInteractionLink)),
+            "locale": lambda n : setattr(self, 'locale', n.get_str_value()),
+            "mentions": lambda n : setattr(self, 'mentions', n.get_collection_of_object_values(AiInteractionMention)),
+            "requestId": lambda n : setattr(self, 'request_id', n.get_str_value()),
+            "sessionId": lambda n : setattr(self, 'session_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_str_value("appClass", self.app_class)
+        writer.write_collection_of_object_values("attachments", self.attachments)
+        writer.write_object_value("body", self.body)
+        writer.write_collection_of_object_values("contexts", self.contexts)
+        writer.write_str_value("conversationType", self.conversation_type)
+        writer.write_datetime_value("createdDateTime", self.created_date_time)
+        writer.write_str_value("etag", self.etag)
+        writer.write_object_value("from", self.from_)
+        writer.write_enum_value("interactionType", self.interaction_type)
+        writer.write_collection_of_object_values("links", self.links)
+        writer.write_str_value("locale", self.locale)
+        writer.write_collection_of_object_values("mentions", self.mentions)
+        writer.write_str_value("requestId", self.request_id)
+        writer.write_str_value("sessionId", self.session_id)
+    
+

msgraph/generated/models/ai_interaction_attachment.py

@@ -0,0 +1,70 @@
+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 AiInteractionAttachment(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 attachmentId property
+    attachment_id: Optional[str] = None
+    # The content property
+    content: Optional[str] = None
+    # The contentType property
+    content_type: Optional[str] = None
+    # The contentUrl property
+    content_url: Optional[str] = None
+    # The name property
+    name: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AiInteractionAttachment:
+        """
+        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: AiInteractionAttachment
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AiInteractionAttachment()
+    
+    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]] = {
+            "attachmentId": lambda n : setattr(self, 'attachment_id', n.get_str_value()),
+            "content": lambda n : setattr(self, 'content', n.get_str_value()),
+            "contentType": lambda n : setattr(self, 'content_type', n.get_str_value()),
+            "contentUrl": lambda n : setattr(self, 'content_url', n.get_str_value()),
+            "name": lambda n : setattr(self, 'name', 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("attachmentId", self.attachment_id)
+        writer.write_str_value("content", self.content)
+        writer.write_str_value("contentType", self.content_type)
+        writer.write_str_value("contentUrl", self.content_url)
+        writer.write_str_value("name", self.name)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/ai_interaction_context.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 AiInteractionContext(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 contextReference property
+    context_reference: Optional[str] = None
+    # The contextType property
+    context_type: Optional[str] = None
+    # The displayName property
+    display_name: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AiInteractionContext:
+        """
+        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: AiInteractionContext
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AiInteractionContext()
+    
+    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]] = {
+            "contextReference": lambda n : setattr(self, 'context_reference', n.get_str_value()),
+            "contextType": lambda n : setattr(self, 'context_type', n.get_str_value()),
+            "displayName": lambda n : setattr(self, 'display_name', 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("contextReference", self.context_reference)
+        writer.write_str_value("contextType", self.context_type)
+        writer.write_str_value("displayName", self.display_name)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/ai_interaction_history.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 AiInteractionHistory(Entity, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AiInteractionHistory:
+        """
+        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: AiInteractionHistory
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AiInteractionHistory()
+    
+    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/ai_interaction_link.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 AiInteractionLink(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 displayName property
+    display_name: Optional[str] = None
+    # The linkType property
+    link_type: Optional[str] = None
+    # The linkUrl property
+    link_url: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AiInteractionLink:
+        """
+        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: AiInteractionLink
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AiInteractionLink()
+    
+    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]] = {
+            "displayName": lambda n : setattr(self, 'display_name', n.get_str_value()),
+            "linkType": lambda n : setattr(self, 'link_type', n.get_str_value()),
+            "linkUrl": lambda n : setattr(self, 'link_url', 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("displayName", self.display_name)
+        writer.write_str_value("linkType", self.link_type)
+        writer.write_str_value("linkUrl", self.link_url)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/ai_interaction_mention.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 .ai_interaction_mentioned_identity_set import AiInteractionMentionedIdentitySet
+
+@dataclass
+class AiInteractionMention(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 mentionId property
+    mention_id: Optional[int] = None
+    # The mentionText property
+    mention_text: Optional[str] = None
+    # The mentioned property
+    mentioned: Optional[AiInteractionMentionedIdentitySet] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AiInteractionMention:
+        """
+        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: AiInteractionMention
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AiInteractionMention()
+    
+    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_mentioned_identity_set import AiInteractionMentionedIdentitySet
+
+        from .ai_interaction_mentioned_identity_set import AiInteractionMentionedIdentitySet
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "mentionId": lambda n : setattr(self, 'mention_id', n.get_int_value()),
+            "mentionText": lambda n : setattr(self, 'mention_text', n.get_str_value()),
+            "mentioned": lambda n : setattr(self, 'mentioned', n.get_object_value(AiInteractionMentionedIdentitySet)),
+            "@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_int_value("mentionId", self.mention_id)
+        writer.write_str_value("mentionText", self.mention_text)
+        writer.write_object_value("mentioned", self.mentioned)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/ai_interaction_mentioned_identity_set.py

@@ -0,0 +1,67 @@
+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 .identity_set import IdentitySet
+    from .teamwork_conversation_identity import TeamworkConversationIdentity
+    from .teamwork_tag_identity import TeamworkTagIdentity
+
+from .identity_set import IdentitySet
+
+@dataclass
+class AiInteractionMentionedIdentitySet(IdentitySet, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.aiInteractionMentionedIdentitySet"
+    # The conversation property
+    conversation: Optional[TeamworkConversationIdentity] = None
+    # The tag property
+    tag: Optional[TeamworkTagIdentity] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AiInteractionMentionedIdentitySet:
+        """
+        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: AiInteractionMentionedIdentitySet
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AiInteractionMentionedIdentitySet()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .identity_set import IdentitySet
+        from .teamwork_conversation_identity import TeamworkConversationIdentity
+        from .teamwork_tag_identity import TeamworkTagIdentity
+
+        from .identity_set import IdentitySet
+        from .teamwork_conversation_identity import TeamworkConversationIdentity
+        from .teamwork_tag_identity import TeamworkTagIdentity
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "conversation": lambda n : setattr(self, 'conversation', n.get_object_value(TeamworkConversationIdentity)),
+            "tag": lambda n : setattr(self, 'tag', n.get_object_value(TeamworkTagIdentity)),
+        }
+        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("conversation", self.conversation)
+        writer.write_object_value("tag", self.tag)
+    
+

msgraph/generated/models/ai_interaction_type.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class AiInteractionType(str, Enum):
+    UserPrompt = "userPrompt",
+    AiResponse = "aiResponse",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/ai_user.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 .ai_interaction_history import AiInteractionHistory
+    from .entity import Entity
+
+from .entity import Entity
+
+@dataclass
+class AiUser(Entity, Parsable):
+    # The interactionHistory property
+    interaction_history: Optional[AiInteractionHistory] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AiUser:
+        """
+        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: AiUser
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AiUser()
+    
+    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_history import AiInteractionHistory
+        from .entity import Entity
+
+        from .ai_interaction_history import AiInteractionHistory
+        from .entity import Entity
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "interactionHistory": lambda n : setattr(self, 'interaction_history', n.get_object_value(AiInteractionHistory)),
+        }
+        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("interactionHistory", self.interaction_history)
+    
+