msgraph-sdk 1.51.0__py3-none-any.whl → 1.52.0__py3-none-any.whl

msgraph/generated/models/work_hours_and_locations_setting.py

@@ -0,0 +1,74 @@
+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 .max_work_location_details import MaxWorkLocationDetails
+    from .work_plan_occurrence import WorkPlanOccurrence
+    from .work_plan_recurrence import WorkPlanRecurrence
+
+from .entity import Entity
+
+@dataclass
+class WorkHoursAndLocationsSetting(Entity, Parsable):
+    # The maxSharedWorkLocationDetails property
+    max_shared_work_location_details: Optional[MaxWorkLocationDetails] = None
+    # Collection of work plan occurrences.
+    occurrences: Optional[list[WorkPlanOccurrence]] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # Collection of recurring work plans defined by the user.
+    recurrences: Optional[list[WorkPlanRecurrence]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> WorkHoursAndLocationsSetting:
+        """
+        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: WorkHoursAndLocationsSetting
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return WorkHoursAndLocationsSetting()
+    
+    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 .max_work_location_details import MaxWorkLocationDetails
+        from .work_plan_occurrence import WorkPlanOccurrence
+        from .work_plan_recurrence import WorkPlanRecurrence
+
+        from .entity import Entity
+        from .max_work_location_details import MaxWorkLocationDetails
+        from .work_plan_occurrence import WorkPlanOccurrence
+        from .work_plan_recurrence import WorkPlanRecurrence
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "maxSharedWorkLocationDetails": lambda n : setattr(self, 'max_shared_work_location_details', n.get_enum_value(MaxWorkLocationDetails)),
+            "occurrences": lambda n : setattr(self, 'occurrences', n.get_collection_of_object_values(WorkPlanOccurrence)),
+            "recurrences": lambda n : setattr(self, 'recurrences', n.get_collection_of_object_values(WorkPlanRecurrence)),
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+        writer.write_enum_value("maxSharedWorkLocationDetails", self.max_shared_work_location_details)
+        writer.write_collection_of_object_values("occurrences", self.occurrences)
+        writer.write_collection_of_object_values("recurrences", self.recurrences)
+    
+

msgraph/generated/models/work_location_source.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class WorkLocationSource(str, Enum):
+    None_ = "none",
+    Manual = "manual",
+    Scheduled = "scheduled",
+    Automatic = "automatic",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/work_location_type.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class WorkLocationType(str, Enum):
+    Unspecified = "unspecified",
+    Office = "office",
+    Remote = "remote",
+    TimeOff = "timeOff",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/work_location_update_scope.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class WorkLocationUpdateScope(str, Enum):
+    CurrentSegment = "currentSegment",
+    CurrentDay = "currentDay",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/work_plan_occurrence.py

@@ -0,0 +1,86 @@
+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 .date_time_time_zone import DateTimeTimeZone
+    from .entity import Entity
+    from .time_off_details import TimeOffDetails
+    from .work_location_type import WorkLocationType
+
+from .entity import Entity
+
+@dataclass
+class WorkPlanOccurrence(Entity, Parsable):
+    # The end property
+    end: Optional[DateTimeTimeZone] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # Identifier of a place from the Microsoft Graph Places Directory API. Only applicable when workLocationType is set to office.
+    place_id: Optional[str] = None
+    # The identifier of the parent recurrence pattern that generated this occurrence. The value is null for time-off occurrences because they don't have a parent recurrence.
+    recurrence_id: Optional[str] = None
+    # The start property
+    start: Optional[DateTimeTimeZone] = None
+    # The details about the time off. Only applicable when workLocationType is set to timeOff.
+    time_off_details: Optional[TimeOffDetails] = None
+    # The workLocationType property
+    work_location_type: Optional[WorkLocationType] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> WorkPlanOccurrence:
+        """
+        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: WorkPlanOccurrence
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return WorkPlanOccurrence()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .date_time_time_zone import DateTimeTimeZone
+        from .entity import Entity
+        from .time_off_details import TimeOffDetails
+        from .work_location_type import WorkLocationType
+
+        from .date_time_time_zone import DateTimeTimeZone
+        from .entity import Entity
+        from .time_off_details import TimeOffDetails
+        from .work_location_type import WorkLocationType
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "end": lambda n : setattr(self, 'end', n.get_object_value(DateTimeTimeZone)),
+            "placeId": lambda n : setattr(self, 'place_id', n.get_str_value()),
+            "recurrenceId": lambda n : setattr(self, 'recurrence_id', n.get_str_value()),
+            "start": lambda n : setattr(self, 'start', n.get_object_value(DateTimeTimeZone)),
+            "timeOffDetails": lambda n : setattr(self, 'time_off_details', n.get_object_value(TimeOffDetails)),
+            "workLocationType": lambda n : setattr(self, 'work_location_type', n.get_enum_value(WorkLocationType)),
+        }
+        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("end", self.end)
+        writer.write_str_value("placeId", self.place_id)
+        writer.write_str_value("recurrenceId", self.recurrence_id)
+        writer.write_object_value("start", self.start)
+        writer.write_object_value("timeOffDetails", self.time_off_details)
+        writer.write_enum_value("workLocationType", self.work_location_type)
+    
+

msgraph/generated/models/work_plan_occurrence_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 .work_plan_occurrence import WorkPlanOccurrence
+
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+
+@dataclass
+class WorkPlanOccurrenceCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[list[WorkPlanOccurrence]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> WorkPlanOccurrenceCollectionResponse:
+        """
+        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: WorkPlanOccurrenceCollectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return WorkPlanOccurrenceCollectionResponse()
+    
+    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 .work_plan_occurrence import WorkPlanOccurrence
+
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .work_plan_occurrence import WorkPlanOccurrence
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(WorkPlanOccurrence)),
+        }
+        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/work_plan_recurrence.py

@@ -0,0 +1,82 @@
+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 .date_time_time_zone import DateTimeTimeZone
+    from .entity import Entity
+    from .patterned_recurrence import PatternedRecurrence
+    from .work_location_type import WorkLocationType
+
+from .entity import Entity
+
+@dataclass
+class WorkPlanRecurrence(Entity, Parsable):
+    # The end property
+    end: Optional[DateTimeTimeZone] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # Identifier of a place from the Microsoft Graph Places Directory API. Only applicable when workLocationType is set to office.
+    place_id: Optional[str] = None
+    # The recurrence property
+    recurrence: Optional[PatternedRecurrence] = None
+    # The start property
+    start: Optional[DateTimeTimeZone] = None
+    # The workLocationType property
+    work_location_type: Optional[WorkLocationType] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> WorkPlanRecurrence:
+        """
+        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: WorkPlanRecurrence
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return WorkPlanRecurrence()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .date_time_time_zone import DateTimeTimeZone
+        from .entity import Entity
+        from .patterned_recurrence import PatternedRecurrence
+        from .work_location_type import WorkLocationType
+
+        from .date_time_time_zone import DateTimeTimeZone
+        from .entity import Entity
+        from .patterned_recurrence import PatternedRecurrence
+        from .work_location_type import WorkLocationType
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "end": lambda n : setattr(self, 'end', n.get_object_value(DateTimeTimeZone)),
+            "placeId": lambda n : setattr(self, 'place_id', n.get_str_value()),
+            "recurrence": lambda n : setattr(self, 'recurrence', n.get_object_value(PatternedRecurrence)),
+            "start": lambda n : setattr(self, 'start', n.get_object_value(DateTimeTimeZone)),
+            "workLocationType": lambda n : setattr(self, 'work_location_type', n.get_enum_value(WorkLocationType)),
+        }
+        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("end", self.end)
+        writer.write_str_value("placeId", self.place_id)
+        writer.write_object_value("recurrence", self.recurrence)
+        writer.write_object_value("start", self.start)
+        writer.write_enum_value("workLocationType", self.work_location_type)
+    
+

msgraph/generated/models/work_plan_recurrence_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 .work_plan_recurrence import WorkPlanRecurrence
+
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+
+@dataclass
+class WorkPlanRecurrenceCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[list[WorkPlanRecurrence]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> WorkPlanRecurrenceCollectionResponse:
+        """
+        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: WorkPlanRecurrenceCollectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return WorkPlanRecurrenceCollectionResponse()
+    
+    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 .work_plan_recurrence import WorkPlanRecurrence
+
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .work_plan_recurrence import WorkPlanRecurrence
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(WorkPlanRecurrence)),
+        }
+        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/workspace.py

@@ -20,10 +20,12 @@ class Workspace(Place, Parsable):
     display_device_name: Optional[str] = None
     # The email address that is associated with the workspace. This email address is used for booking.
     email_address: Optional[str] = None
-    # The mode for a workspace. The supported modes are:reservablePlaceMode - Workspaces that can be booked in advance using desk pool reservation tools.dropInPlaceMode - First come, first served desks. When you plug into a peripheral on one of these desks in the workspace, the desk is booked for you, assuming that the peripheral has been associated with the desk in the Microsoft Teams Rooms Pro management portal.
+    # The mode for a workspace. The supported modes are:reservablePlaceMode - Workspaces that can be booked in advance using desk pool reservation tools.dropInPlaceMode - First come, first served desks. When you plug into a peripheral on one of these desks in the workspace, the desk is booked for you, assuming that the peripheral has been associated with the desk in the Microsoft Teams Rooms pro management portal.unavailablePlaceMode - Workspaces that are taken down for maintenance or marked as not reservable.
     mode: Optional[PlaceMode] = None
     # A short, friendly name for the workspace, often used for easier identification or display in the UI.
     nickname: Optional[str] = None
+    # An alternative immutable unique identifier of the workspace. Read-only.
+    place_id: Optional[str] = None
     
     @staticmethod
     def create_from_discriminator_value(parse_node: ParseNode) -> Workspace:
@@ -53,6 +55,7 @@ class Workspace(Place, Parsable):
             "emailAddress": lambda n : setattr(self, 'email_address', n.get_str_value()),
             "mode": lambda n : setattr(self, 'mode', n.get_object_value(PlaceMode)),
             "nickname": lambda n : setattr(self, 'nickname', n.get_str_value()),
+            "placeId": lambda n : setattr(self, 'place_id', n.get_str_value()),
         }
         super_fields = super().get_field_deserializers()
         fields.update(super_fields)
@@ -72,5 +75,6 @@ class Workspace(Place, Parsable):
         writer.write_str_value("emailAddress", self.email_address)
         writer.write_object_value("mode", self.mode)
         writer.write_str_value("nickname", self.nickname)
+        writer.write_str_value("placeId", self.place_id)
     
 

msgraph/generated/security/cases/ediscovery_cases/item/case_members/case_members_request_builder.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.base_request_builder import BaseRequestBuilder
+from kiota_abstractions.base_request_configuration import RequestConfiguration
+from kiota_abstractions.default_query_parameters import QueryParameters
+from kiota_abstractions.get_path_parameters import get_path_parameters
+from kiota_abstractions.method import Method
+from kiota_abstractions.request_adapter import RequestAdapter
+from kiota_abstractions.request_information import RequestInformation
+from kiota_abstractions.request_option import RequestOption
+from kiota_abstractions.serialization import Parsable, ParsableFactory
+from typing import Any, Optional, TYPE_CHECKING, Union
+from warnings import warn
+
+if TYPE_CHECKING:
+    from ......models.o_data_errors.o_data_error import ODataError
+    from ......models.security.ediscovery_case_member import EdiscoveryCaseMember
+    from ......models.security.ediscovery_case_member_collection_response import EdiscoveryCaseMemberCollectionResponse
+    from .count.count_request_builder import CountRequestBuilder
+    from .item.ediscovery_case_member_item_request_builder import EdiscoveryCaseMemberItemRequestBuilder
+
+class CaseMembersRequestBuilder(BaseRequestBuilder):
+    """
+    Provides operations to manage the caseMembers property of the microsoft.graph.security.ediscoveryCase entity.
+    """
+    def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, dict[str, Any]]) -> None:
+        """
+        Instantiates a new CaseMembersRequestBuilder and sets the default values.
+        param path_parameters: The raw url or the url-template parameters for the request.
+        param request_adapter: The request adapter to use to execute the requests.
+        Returns: None
+        """
+        super().__init__(request_adapter, "{+baseurl}/security/cases/ediscoveryCases/{ediscoveryCase%2Did}/caseMembers{?%24count,%24expand,%24filter,%24orderby,%24search,%24select,%24skip,%24top}", path_parameters)
+    
+    def by_ediscovery_case_member_id(self,ediscovery_case_member_id: str) -> EdiscoveryCaseMemberItemRequestBuilder:
+        """
+        Provides operations to manage the caseMembers property of the microsoft.graph.security.ediscoveryCase entity.
+        param ediscovery_case_member_id: The unique identifier of ediscoveryCaseMember
+        Returns: EdiscoveryCaseMemberItemRequestBuilder
+        """
+        if ediscovery_case_member_id is None:
+            raise TypeError("ediscovery_case_member_id cannot be null.")
+        from .item.ediscovery_case_member_item_request_builder import EdiscoveryCaseMemberItemRequestBuilder
+
+        url_tpl_params = get_path_parameters(self.path_parameters)
+        url_tpl_params["ediscoveryCaseMember%2Did"] = ediscovery_case_member_id
+        return EdiscoveryCaseMemberItemRequestBuilder(self.request_adapter, url_tpl_params)
+    
+    async def get(self,request_configuration: Optional[RequestConfiguration[CaseMembersRequestBuilderGetQueryParameters]] = None) -> Optional[EdiscoveryCaseMemberCollectionResponse]:
+        """
+        Get a list of ediscoveryCaseMember objects for an ediscoveryCase.
+        param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
+        Returns: Optional[EdiscoveryCaseMemberCollectionResponse]
+        Find more info here: https://learn.microsoft.com/graph/api/security-ediscoverycasemember-list?view=graph-rest-1.0
+        """
+        request_info = self.to_get_request_information(
+            request_configuration
+        )
+        from ......models.o_data_errors.o_data_error import ODataError
+
+        error_mapping: dict[str, type[ParsableFactory]] = {
+            "XXX": ODataError,
+        }
+        if not self.request_adapter:
+            raise Exception("Http core is null") 
+        from ......models.security.ediscovery_case_member_collection_response import EdiscoveryCaseMemberCollectionResponse
+
+        return await self.request_adapter.send_async(request_info, EdiscoveryCaseMemberCollectionResponse, error_mapping)
+    
+    async def post(self,body: EdiscoveryCaseMember, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[EdiscoveryCaseMember]:
+        """
+        Add an ediscoveryCaseMember to an ediscoveryCase. The ediscoveryCaseMember can be one of two types: a user or a role group.
+        param body: The request body
+        param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
+        Returns: Optional[EdiscoveryCaseMember]
+        Find more info here: https://learn.microsoft.com/graph/api/security-ediscoverycasemember-post?view=graph-rest-1.0
+        """
+        if body is None:
+            raise TypeError("body cannot be null.")
+        request_info = self.to_post_request_information(
+            body, request_configuration
+        )
+        from ......models.o_data_errors.o_data_error import ODataError
+
+        error_mapping: dict[str, type[ParsableFactory]] = {
+            "XXX": ODataError,
+        }
+        if not self.request_adapter:
+            raise Exception("Http core is null") 
+        from ......models.security.ediscovery_case_member import EdiscoveryCaseMember
+
+        return await self.request_adapter.send_async(request_info, EdiscoveryCaseMember, error_mapping)
+    
+    def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[CaseMembersRequestBuilderGetQueryParameters]] = None) -> RequestInformation:
+        """
+        Get a list of ediscoveryCaseMember objects for an ediscoveryCase.
+        param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
+        Returns: RequestInformation
+        """
+        request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters)
+        request_info.configure(request_configuration)
+        request_info.headers.try_add("Accept", "application/json")
+        return request_info
+    
+    def to_post_request_information(self,body: EdiscoveryCaseMember, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation:
+        """
+        Add an ediscoveryCaseMember to an ediscoveryCase. The ediscoveryCaseMember can be one of two types: a user or a role group.
+        param body: The request body
+        param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
+        Returns: RequestInformation
+        """
+        if body is None:
+            raise TypeError("body cannot be null.")
+        request_info = RequestInformation(Method.POST, self.url_template, self.path_parameters)
+        request_info.configure(request_configuration)
+        request_info.headers.try_add("Accept", "application/json")
+        request_info.set_content_from_parsable(self.request_adapter, "application/json", body)
+        return request_info
+    
+    def with_url(self,raw_url: str) -> CaseMembersRequestBuilder:
+        """
+        Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        param raw_url: The raw URL to use for the request builder.
+        Returns: CaseMembersRequestBuilder
+        """
+        if raw_url is None:
+            raise TypeError("raw_url cannot be null.")
+        return CaseMembersRequestBuilder(self.request_adapter, raw_url)
+    
+    @property
+    def count(self) -> CountRequestBuilder:
+        """
+        Provides operations to count the resources in the collection.
+        """
+        from .count.count_request_builder import CountRequestBuilder
+
+        return CountRequestBuilder(self.request_adapter, self.path_parameters)
+    
+    @dataclass
+    class CaseMembersRequestBuilderGetQueryParameters():
+        """
+        Get a list of ediscoveryCaseMember objects for an ediscoveryCase.
+        """
+        def get_query_parameter(self,original_name: str) -> str:
+            """
+            Maps the query parameters names to their encoded names for the URI template parsing.
+            param original_name: The original query parameter name in the class.
+            Returns: str
+            """
+            if original_name is None:
+                raise TypeError("original_name cannot be null.")
+            if original_name == "count":
+                return "%24count"
+            if original_name == "expand":
+                return "%24expand"
+            if original_name == "filter":
+                return "%24filter"
+            if original_name == "orderby":
+                return "%24orderby"
+            if original_name == "search":
+                return "%24search"
+            if original_name == "select":
+                return "%24select"
+            if original_name == "skip":
+                return "%24skip"
+            if original_name == "top":
+                return "%24top"
+            return original_name
+        
+        # Include count of items
+        count: Optional[bool] = None
+
+        # Expand related entities
+        expand: Optional[list[str]] = None
+
+        # Filter items by property values
+        filter: Optional[str] = None
+
+        # Order items by property values
+        orderby: Optional[list[str]] = None
+
+        # Search items by search phrases
+        search: Optional[str] = None
+
+        # Select properties to be returned
+        select: Optional[list[str]] = None
+
+        # Skip the first n items
+        skip: Optional[int] = None
+
+        # Show only the first n items
+        top: Optional[int] = None
+
+    
+    @dataclass
+    class CaseMembersRequestBuilderGetRequestConfiguration(RequestConfiguration[CaseMembersRequestBuilderGetQueryParameters]):
+        """
+        Configuration for the request such as headers, query parameters, and middleware options.
+        """
+        warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning)
+    
+    @dataclass
+    class CaseMembersRequestBuilderPostRequestConfiguration(RequestConfiguration[QueryParameters]):
+        """
+        Configuration for the request such as headers, query parameters, and middleware options.
+        """
+        warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning)
+    
+