msgraph-sdk 1.48.0__py3-none-any.whl → 1.50.0__py3-none-any.whl

msgraph/generated/models/check_in_claim_collection_response.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+    from .check_in_claim import CheckInClaim
+
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+
+@dataclass
+class CheckInClaimCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[list[CheckInClaim]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> CheckInClaimCollectionResponse:
+        """
+        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: CheckInClaimCollectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return CheckInClaimCollectionResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .check_in_claim import CheckInClaim
+
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .check_in_claim import CheckInClaim
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(CheckInClaim)),
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+        writer.write_collection_of_object_values("value", self.value)
+    
+

msgraph/generated/models/check_in_method.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class CheckInMethod(str, Enum):
+    Unspecified = "unspecified",
+    Manual = "manual",
+    Inferred = "inferred",
+    Verified = "verified",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/cloud_flare_rule_model.py

@@ -12,13 +12,13 @@ class CloudFlareRuleModel(AdditionalDataHolder, BackedModel, Parsable):
 
     # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
     additional_data: dict[str, Any] = field(default_factory=dict)
-    # The action property
+    # The action Cloudflare applies when the rule matches traffic. Common values include Managed Challenge, Interactive Challenge, Log, Block, JS Challenge, or Skip.
     action: Optional[str] = None
-    # The name property
+    # Friendly name for the rule, used in UIs or logs to help administrators identify the rule.
     name: Optional[str] = None
     # The OdataType property
     odata_type: Optional[str] = None
-    # The ruleId property
+    # Unique identifier assigned to the rule by Cloudflare or the integration.
     rule_id: Optional[str] = None
     
     @staticmethod

msgraph/generated/models/cloud_flare_ruleset_model.py

@@ -12,13 +12,13 @@ class CloudFlareRulesetModel(AdditionalDataHolder, BackedModel, Parsable):
 
     # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
     additional_data: dict[str, Any] = field(default_factory=dict)
-    # The name property
+    # Friendly name for the ruleset, used in UIs and logs to help administrators identify the ruleset.
     name: Optional[str] = None
     # The OdataType property
     odata_type: Optional[str] = None
-    # The phaseName property
+    # Name of the phase during which the ruleset is evaluated (for example, httprequestfirewallmanaged, httprequestfirewallcustom, or provider-specific phase names). This indicates when in the request/response lifecycle the rules apply.
     phase_name: Optional[str] = None
-    # The rulesetId property
+    # Unique identifier assigned to the ruleset by Cloudflare or the integration.
     ruleset_id: Optional[str] = None
     
     @staticmethod

msgraph/generated/models/cloud_flare_verified_details_model.py

@@ -15,11 +15,11 @@ from .web_application_firewall_verified_details import WebApplicationFirewallVer
 class CloudFlareVerifiedDetailsModel(WebApplicationFirewallVerifiedDetails, Parsable):
     # The OdataType property
     odata_type: Optional[str] = "#microsoft.graph.cloudFlareVerifiedDetailsModel"
-    # The enabledCustomRules property
+    # Collection of Cloudflare custom rules that are currently enabled for the zone or host.
     enabled_custom_rules: Optional[list[CloudFlareRuleModel]] = None
-    # The enabledRecommendedRulesets property
+    # Collection of Cloudflare recommended rulesets that are enabled for the zone or host.
     enabled_recommended_rulesets: Optional[list[CloudFlareRulesetModel]] = None
-    # The zoneId property
+    # Cloudflare-assigned identifier for the DNS zone associated with the verified host (for example, the Cloudflare Zone ID). This ID is used to correlate verification details with the Cloudflare account and to perform configuration operations via the provider's API.
     zone_id: Optional[str] = None
     
     @staticmethod

msgraph/generated/models/cloud_flare_web_application_firewall_provider.py

@@ -13,9 +13,9 @@ from .web_application_firewall_provider import WebApplicationFirewallProvider
 class CloudFlareWebApplicationFirewallProvider(WebApplicationFirewallProvider, Parsable):
     # The OdataType property
     odata_type: Optional[str] = "#microsoft.graph.cloudFlareWebApplicationFirewallProvider"
-    # The apiToken property
+    # Cloudflare API token or credential used by Microsoft services to authenticate to the Cloudflare account. Contact your Cloudflare Customer Success Manager for assistance with your apitoken.
     api_token: Optional[str] = None
-    # The zoneId property
+    # Default Cloudflare Zone ID associated with this provider configuration. This ID identifies the DNS zone in Cloudflare that is commonly used for verification and configuration operations for the provider.
     zone_id: Optional[str] = None
     
     @staticmethod

msgraph/generated/models/communications_guest_identity.py

@@ -13,6 +13,8 @@ from .identity import Identity
 class CommunicationsGuestIdentity(Identity, Parsable):
     # The OdataType property
     odata_type: Optional[str] = "#microsoft.graph.communicationsGuestIdentity"
+    # The email of the guest user.
+    email: Optional[str] = None
     
     @staticmethod
     def create_from_discriminator_value(parse_node: ParseNode) -> CommunicationsGuestIdentity:
@@ -35,6 +37,7 @@ class CommunicationsGuestIdentity(Identity, Parsable):
         from .identity import Identity
 
         fields: dict[str, Callable[[Any], None]] = {
+            "email": lambda n : setattr(self, 'email', n.get_str_value()),
         }
         super_fields = super().get_field_deserializers()
         fields.update(super_fields)
@@ -49,5 +52,6 @@ class CommunicationsGuestIdentity(Identity, Parsable):
         if writer is None:
             raise TypeError("writer cannot be null.")
         super().serialize(writer)
+        writer.write_str_value("email", self.email)
     
 

msgraph/generated/models/copilot_report_root.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 CopilotReportRoot(Entity, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> CopilotReportRoot:
+        """
+        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: CopilotReportRoot
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return CopilotReportRoot()
+    
+    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/desk.py

@@ -0,0 +1,71 @@
+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 .mailbox_details import MailboxDetails
+    from .place import Place
+    from .place_mode import PlaceMode
+
+from .place import Place
+
+@dataclass
+class Desk(Place, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.desk"
+    # The displayDeviceName property
+    display_device_name: Optional[str] = None
+    # The mailboxDetails property
+    mailbox_details: Optional[MailboxDetails] = None
+    # The mode property
+    mode: Optional[PlaceMode] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> Desk:
+        """
+        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: Desk
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return Desk()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .mailbox_details import MailboxDetails
+        from .place import Place
+        from .place_mode import PlaceMode
+
+        from .mailbox_details import MailboxDetails
+        from .place import Place
+        from .place_mode import PlaceMode
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "displayDeviceName": lambda n : setattr(self, 'display_device_name', n.get_str_value()),
+            "mailboxDetails": lambda n : setattr(self, 'mailbox_details', n.get_object_value(MailboxDetails)),
+            "mode": lambda n : setattr(self, 'mode', n.get_object_value(PlaceMode)),
+        }
+        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("displayDeviceName", self.display_device_name)
+        writer.write_object_value("mailboxDetails", self.mailbox_details)
+        writer.write_object_value("mode", self.mode)
+    
+

msgraph/generated/models/desk_collection_response.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+    from .desk import Desk
+
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+
+@dataclass
+class DeskCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[list[Desk]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> DeskCollectionResponse:
+        """
+        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: DeskCollectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return DeskCollectionResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .desk import Desk
+
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .desk import Desk
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(Desk)),
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+        writer.write_collection_of_object_values("value", self.value)
+    
+

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

@@ -81,7 +81,7 @@ class EducationAssignment(Entity, Parsable):
     resources_folder_url: Optional[str] = None
     # When set, the grading rubric attached to this assignment.
     rubric: Optional[EducationRubric] = None
-    # Status of the assignment.  You can't PATCH this value. Possible values are: draft, scheduled, published, assigned, unknownFutureValue, inactive. Use the Prefer: include-unknown-enum-members request header to get the following value(s) in this evolvable enum: inactive.
+    # Status of the assignment.  You can't PATCH this value. Possible values are: draft, scheduled, published, assigned, unknownFutureValue, inactive. Use the Prefer: include-unknown-enum-members request header to get the following members in this evolvable enum: inactive.
     status: Optional[EducationAssignmentStatus] = None
     # Once published, there's a submission object for each student representing their work and grade. Read-only. Nullable.
     submissions: Optional[list[EducationSubmission]] = None

msgraph/generated/models/education_assignment_defaults.py

@@ -14,7 +14,7 @@ from .entity import Entity
 
 @dataclass
 class EducationAssignmentDefaults(Entity, Parsable):
-    # Optional field to control adding assignments to students' and teachers' calendars when the assignment is published. The possible values are: none, studentsAndPublisher, studentsAndTeamOwners, unknownFutureValue, and studentsOnly. Use the Prefer: include-unknown-enum-members request header to get the following value in this evolvable enum: studentsOnly. The default value is none.
+    # Optional field to control adding assignments to students' and teachers' calendars when the assignment is published. The possible values are: none, studentsAndPublisher, studentsAndTeamOwners, unknownFutureValue, and studentsOnly. Use the Prefer: include-unknown-enum-members request header to get the following members in this evolvable enum: studentsOnly. The default value is none.
     add_to_calendar_action: Optional[EducationAddToCalendarOptions] = None
     # Class-level default behavior for handling students who are added after the assignment is published. Possible values are: none, assignIfOpen.
     added_student_action: Optional[EducationAddedStudentAction] = None

msgraph/generated/models/employee_experience.py

@@ -8,6 +8,7 @@ from typing import Any, Optional, TYPE_CHECKING, Union
 if TYPE_CHECKING:
     from .community import Community
     from .engagement_async_operation import EngagementAsyncOperation
+    from .engagement_role import EngagementRole
     from .learning_course_activity import LearningCourseActivity
     from .learning_provider import LearningProvider
 
@@ -31,6 +32,8 @@ class EmployeeExperience(AdditionalDataHolder, BackedModel, Parsable):
     learning_providers: Optional[list[LearningProvider]] = None
     # The OdataType property
     odata_type: Optional[str] = None
+    # A collection of roles in Viva Engage.
+    roles: Optional[list[EngagementRole]] = None
     
     @staticmethod
     def create_from_discriminator_value(parse_node: ParseNode) -> EmployeeExperience:
@@ -50,11 +53,13 @@ class EmployeeExperience(AdditionalDataHolder, BackedModel, Parsable):
         """
         from .community import Community
         from .engagement_async_operation import EngagementAsyncOperation
+        from .engagement_role import EngagementRole
         from .learning_course_activity import LearningCourseActivity
         from .learning_provider import LearningProvider
 
         from .community import Community
         from .engagement_async_operation import EngagementAsyncOperation
+        from .engagement_role import EngagementRole
         from .learning_course_activity import LearningCourseActivity
         from .learning_provider import LearningProvider
 
@@ -64,6 +69,7 @@ class EmployeeExperience(AdditionalDataHolder, BackedModel, Parsable):
             "learningCourseActivities": lambda n : setattr(self, 'learning_course_activities', n.get_collection_of_object_values(LearningCourseActivity)),
             "learningProviders": lambda n : setattr(self, 'learning_providers', n.get_collection_of_object_values(LearningProvider)),
             "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "roles": lambda n : setattr(self, 'roles', n.get_collection_of_object_values(EngagementRole)),
         }
         return fields
     
@@ -80,6 +86,7 @@ class EmployeeExperience(AdditionalDataHolder, BackedModel, Parsable):
         writer.write_collection_of_object_values("learningCourseActivities", self.learning_course_activities)
         writer.write_collection_of_object_values("learningProviders", self.learning_providers)
         writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_collection_of_object_values("roles", self.roles)
         writer.write_additional_data_value(self.additional_data)
     
 

msgraph/generated/models/employee_experience_user.py

@@ -5,6 +5,7 @@ from kiota_abstractions.serialization import Parsable, ParseNode, SerializationW
 from typing import Any, Optional, TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
+    from .engagement_role import EngagementRole
     from .entity import Entity
     from .learning_course_activity import LearningCourseActivity
 
@@ -12,6 +13,8 @@ from .entity import Entity
 
 @dataclass
 class EmployeeExperienceUser(Entity, Parsable):
+    # Represents the collection of Viva Engage roles assigned to a user.
+    assigned_roles: Optional[list[EngagementRole]] = None
     # The learningCourseActivities property
     learning_course_activities: Optional[list[LearningCourseActivity]] = None
     # The OdataType property
@@ -33,13 +36,16 @@ class EmployeeExperienceUser(Entity, Parsable):
         The deserialization information for the current model
         Returns: dict[str, Callable[[ParseNode], None]]
         """
+        from .engagement_role import EngagementRole
         from .entity import Entity
         from .learning_course_activity import LearningCourseActivity
 
+        from .engagement_role import EngagementRole
         from .entity import Entity
         from .learning_course_activity import LearningCourseActivity
 
         fields: dict[str, Callable[[Any], None]] = {
+            "assignedRoles": lambda n : setattr(self, 'assigned_roles', n.get_collection_of_object_values(EngagementRole)),
             "learningCourseActivities": lambda n : setattr(self, 'learning_course_activities', n.get_collection_of_object_values(LearningCourseActivity)),
         }
         super_fields = super().get_field_deserializers()
@@ -55,6 +61,7 @@ class EmployeeExperienceUser(Entity, Parsable):
         if writer is None:
             raise TypeError("writer cannot be null.")
         super().serialize(writer)
+        writer.write_collection_of_object_values("assignedRoles", self.assigned_roles)
         writer.write_collection_of_object_values("learningCourseActivities", self.learning_course_activities)
     
 

msgraph/generated/models/engagement_role.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 .engagement_role_member import EngagementRoleMember
+    from .entity import Entity
+
+from .entity import Entity
+
+@dataclass
+class EngagementRole(Entity, Parsable):
+    """
+    Represents a Viva Engage role and its members
+    """
+    # The name of the role.
+    display_name: Optional[str] = None
+    # Users that have this role assigned.
+    members: Optional[list[EngagementRoleMember]] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> EngagementRole:
+        """
+        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: EngagementRole
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return EngagementRole()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .engagement_role_member import EngagementRoleMember
+        from .entity import Entity
+
+        from .engagement_role_member import EngagementRoleMember
+        from .entity import Entity
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "displayName": lambda n : setattr(self, 'display_name', n.get_str_value()),
+            "members": lambda n : setattr(self, 'members', n.get_collection_of_object_values(EngagementRoleMember)),
+        }
+        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_collection_of_object_values("members", self.members)
+    
+

msgraph/generated/models/engagement_role_collection_response.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+    from .engagement_role import EngagementRole
+
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+
+@dataclass
+class EngagementRoleCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[list[EngagementRole]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> EngagementRoleCollectionResponse:
+        """
+        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: EngagementRoleCollectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return EngagementRoleCollectionResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .engagement_role import EngagementRole
+
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .engagement_role import EngagementRole
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(EngagementRole)),
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+        writer.write_collection_of_object_values("value", self.value)
+    
+