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

msgraph/generated/kiota-lock.json

@@ -1,8 +1,8 @@
 {
-  "descriptionHash": "4681793C8F3B1E88B820DC2864FDBD9CEBBECDC8A4E0AB6F0CD58A2B4B910E0A02EDCFCAADB436613C1276EADE1BCD033BEB57AD8FB465F32C56AD9B44CBA253",
+  "descriptionHash": "B5A4149FBFB92197EAAB2C6C1D0D838E942250C69CAC42920E6E6E97F32889B5B1F565896EC586A62B27666BE7B11D89EA2BE073B9E77A0AA1252F3A156D33C2",
   "descriptionLocation": "../../msgraph-metadata/clean_v10_openapi/openapi.yaml",
   "lockFileVersion": "1.0.0",
-  "kiotaVersion": "1.25.1",
+  "kiotaVersion": "1.27.0",
   "clientClassName": "BaseGraphServiceClient",
   "typeAccessModifier": "Public",
   "clientNamespaceName": "msgraph.generated",

msgraph/generated/models/access_package_assignment_approval_settings.py

@@ -19,7 +19,7 @@ class AccessPackageAssignmentApprovalSettings(AdditionalDataHolder, BackedModel,
     is_approval_required_for_add: Optional[bool] = None
     # If false, then approval isn't required for updates to requests in this policy.
     is_approval_required_for_update: Optional[bool] = None
-    # The isRequestorJustificationRequired property
+    # If false, then requestor justification isn't required for updates to requests in this policy.
     is_requestor_justification_required: Optional[bool] = None
     # The OdataType property
     odata_type: Optional[str] = None

msgraph/generated/models/access_package_assignment_request.py

@@ -32,7 +32,7 @@ class AccessPackageAssignmentRequest(Entity, Parsable):
     created_date_time: Optional[datetime.datetime] = None
     # Information about all the custom extension calls that were made during the access package assignment workflow.
     custom_extension_callout_instances: Optional[list[CustomExtensionCalloutInstance]] = None
-    # The justification property
+    # The requestor's supplied justification.
     justification: Optional[str] = None
     # The OdataType property
     odata_type: Optional[str] = None

msgraph/generated/models/access_package_assignment_request_requirements.py

@@ -22,7 +22,7 @@ class AccessPackageAssignmentRequestRequirements(AdditionalDataHolder, BackedMod
     is_approval_required_for_add: Optional[bool] = None
     # Indicates whether a request to update must be approved by an approver.
     is_approval_required_for_update: Optional[bool] = None
-    # The isRequestorJustificationRequired property
+    # Indicates whether requestors must justify requesting access to an access package.
     is_requestor_justification_required: Optional[bool] = None
     # The OdataType property
     odata_type: Optional[str] = None

msgraph/generated/models/access_package_notification_settings.py

@@ -12,7 +12,7 @@ class AccessPackageNotificationSettings(AdditionalDataHolder, BackedModel, Parsa
 
     # 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 isAssignmentNotificationDisabled property
+    # Indicates if notification emails for an access package are disabled within an access package assignment policy.
     is_assignment_notification_disabled: Optional[bool] = None
     # The OdataType property
     odata_type: Optional[str] = None

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)
+    
+

msgraph/generated/models/application.py

@@ -76,7 +76,7 @@ class Application(DirectoryObject, Parsable):
     group_membership_claims: Optional[str] = None
     # The homeRealmDiscoveryPolicies property
     home_realm_discovery_policies: Optional[list[HomeRealmDiscoveryPolicy]] = None
-    # Also known as App ID URI, this value is set when an application is used as a resource app. The identifierUris acts as the prefix for the scopes you reference in your API's code, and it must be globally unique. You can use the default value provided, which is in the form api://<appId>, or specify a more readable URI like https://contoso.com/api. For more information on valid identifierUris patterns and best practices, see Microsoft Entra application registration security best practices. Not nullable. Supports $filter (eq, ne, ge, le, startsWith).
+    # Also known as App ID URI, this value is set when an application is used as a resource app. The identifierUris acts as the prefix for the scopes you reference in your API's code, and it must be globally unique. For more information on valid identifierUris patterns and best practices, see Microsoft Entra application registration security best practices. Not nullable. Supports $filter (eq, ne, ge, le, startsWith).
     identifier_uris: Optional[list[str]] = None
     # Basic profile information of the application such as  app's marketing, support, terms of service and privacy statement URLs. The terms of service and privacy statement are surfaced to users through the user consent experience. For more info, see How to: Add Terms of service and privacy statement for registered Microsoft Entra apps. Supports $filter (eq, ne, not, ge, le, and eq on null values).
     info: Optional[InformationalUrl] = None