msgraph-sdk 1.30.0__py3-none-any.whl → 1.32.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 data source for Copilot data. For example, IPM.SkypeTeams.Message.Copilot.Excel or IPM.SkypeTeams.Message.Copilot.Loop.
+    app_class: Optional[str] = None
+    # The collection of documents attached to the interaction, such as cards and images.
+    attachments: Optional[list[AiInteractionAttachment]] = None
+    # The body of the message, including the text of the body and its body type.
+    body: Optional[ItemBody] = None
+    # The identifer that maps to all contexts associated with an interaction.
+    contexts: Optional[list[AiInteractionContext]] = None
+    # The type of the conversation. For example, appchat or bizchat.
+    conversation_type: Optional[str] = None
+    # The time when the interaction was created.
+    created_date_time: Optional[datetime.datetime] = None
+    # The timestamp of when the interaction was last modified.
+    etag: Optional[str] = None
+    # The from property
+    from_: Optional[IdentitySet] = None
+    # The interactionType property
+    interaction_type: Optional[AiInteractionType] = None
+    # The collection of links that appear in the interaction.
+    links: Optional[list[AiInteractionLink]] = None
+    # The locale of the sender.
+    locale: Optional[str] = None
+    # The collection of the entities that were mentioned in the interaction, including users, bots, and so on.
+    mentions: Optional[list[AiInteractionMention]] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The identifier that groups a user prompt with its Copilot response.
+    request_id: Optional[str] = None
+    # The thread ID or conversation identifier that maps to all Copilot sessions for the user.
+    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,73 @@
+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 AiInteractionAttachment(Entity, Parsable):
+    # The identifier for the attachment. This identifier is only unique within the message scope.
+    attachment_id: Optional[str] = None
+    # The content of the attachment.
+    content: Optional[str] = None
+    # The type of the content. For example, reference, file, and image/imageType.
+    content_type: Optional[str] = None
+    # The URL of the content.
+    content_url: Optional[str] = None
+    # The name of the attachment.
+    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]]
+        """
+        from .entity import Entity
+
+        from .entity import Entity
+
+        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()),
+        }
+        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("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)
+    
+

msgraph/generated/models/ai_interaction_context.py

@@ -0,0 +1,65 @@
+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 AiInteractionContext(Entity, Parsable):
+    # The full file URL where the interaction happened.
+    context_reference: Optional[str] = None
+    # The type of the file.
+    context_type: Optional[str] = None
+    # The name of the file.
+    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]]
+        """
+        from .entity import Entity
+
+        from .entity import Entity
+
+        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()),
+        }
+        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("contextReference", self.context_reference)
+        writer.write_str_value("contextType", self.context_type)
+        writer.write_str_value("displayName", self.display_name)
+    
+

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,65 @@
+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 AiInteractionLink(Entity, Parsable):
+    # The name of the link.
+    display_name: Optional[str] = None
+    # Information about a link in an app chat or Business Chat (BizChat) interaction.
+    link_type: Optional[str] = None
+    # The URL of the link.
+    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]]
+        """
+        from .entity import Entity
+
+        from .entity import Entity
+
+        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()),
+        }
+        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("displayName", self.display_name)
+        writer.write_str_value("linkType", self.link_type)
+        writer.write_str_value("linkUrl", self.link_url)
+    
+

msgraph/generated/models/ai_interaction_mention.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_mentioned_identity_set import AiInteractionMentionedIdentitySet
+    from .entity import Entity
+
+from .entity import Entity
+
+@dataclass
+class AiInteractionMention(Entity, Parsable):
+    # The identifier for the mention.
+    mention_id: Optional[int] = None
+    # The text mentioned in the message.
+    mention_text: Optional[str] = None
+    # The entity mentioned in the message.
+    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 .entity import Entity
+
+        from .ai_interaction_mentioned_identity_set import AiInteractionMentionedIdentitySet
+        from .entity import Entity
+
+        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)),
+        }
+        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_int_value("mentionId", self.mention_id)
+        writer.write_str_value("mentionText", self.mention_text)
+        writer.write_object_value("mentioned", self.mentioned)
+    
+

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 details.
+    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 history of interactions between AI agents and users.
+    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/app_scope.py

@@ -11,11 +11,11 @@ from .entity import Entity
 
 @dataclass
 class AppScope(Entity, Parsable):
-    # Provides the display name of the app-specific resource represented by the app scope. Provided for display purposes since appScopeId is often an immutable, non-human-readable id. Read-only.
+    # Provides the display name of the app-specific resource represented by the app scope. Read only.
     display_name: Optional[str] = None
     # The OdataType property
     odata_type: Optional[str] = None
-    # Describes the type of app-specific resource represented by the app scope and is provided for display purposes, so a user interface can convey to the user the kind of app specific resource represented by the app scope. Read-only.
+    # Describes the type of app-specific resource represented by the app scope. Read-only.
     type: Optional[str] = None
     
     @staticmethod

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. 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 across Microsoft Entra ID. 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

msgraph/generated/models/audit_activity_initiator.py

@@ -16,11 +16,11 @@ class AuditActivityInitiator(AdditionalDataHolder, BackedModel, Parsable):
 
     # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
     additional_data: dict[str, Any] = field(default_factory=dict)
-    # If the resource initiating the activity is an app, this property indicates all the app related information like appId, Name, servicePrincipalId, Name.
+    # If the resource initiating the activity is an app, this property indicates all the app related information like appId and name.
     app: Optional[AppIdentity] = None
     # The OdataType property
     odata_type: Optional[str] = None
-    # If the resource initiating the activity is a user, this property Indicates all the user related information like userId, Name, UserPrinicpalName.
+    # If the resource initiating the activity is a user, this property Indicates all the user related information like user ID and userPrincipalName.
     user: Optional[UserIdentity] = None
     
     @staticmethod