msgraph-sdk 1.20.0__py3-none-any.whl → 1.21.0__py3-none-any.whl

msgraph/generated/models/search/qna.py

@@ -34,7 +34,7 @@ class Qna(SearchAnswer, Parsable):
     platforms: Optional[list[DevicePlatformType]] = None
     # The state property
     state: Optional[AnswerState] = None
-    # Variations of a QnA for different countries or devices. Use when you need to show different content to users based on their device, country/region, or both. The date and group settings apply to all variations.
+    # Variations of a QnA for different countries/regions or devices. Use when you need to show different content to users based on their device, country/region, or both. The date and group settings apply to all variations.
     targeted_variations: Optional[list[AnswerVariant]] = None
     
     @staticmethod

msgraph/generated/models/service_principal.py

@@ -104,7 +104,7 @@ class ServicePrincipal(DirectoryObject, Parsable):
     oauth2_permission_scopes: Optional[list[PermissionScope]] = None
     # Directory objects that this service principal owns. Read-only. Nullable. Supports $expand, $select nested in $expand, and $filter (/$count eq 0, /$count ne 0, /$count eq 1, /$count ne 1).
     owned_objects: Optional[list[DirectoryObject]] = None
-    # Directory objects that are owners of this servicePrincipal. The owners are a set of nonadmin users or servicePrincipals who are allowed to modify this object. Read-only. Nullable. Supports $expand, $filter (/$count eq 0, /$count ne 0, /$count eq 1, /$count ne 1), and $select nested in $expand.
+    # Directory objects that are owners of this servicePrincipal. The owners are a set of nonadmin users or servicePrincipals who are allowed to modify this object. Supports $expand, $filter (/$count eq 0, /$count ne 0, /$count eq 1, /$count ne 1), and $select nested in $expand.
     owners: Optional[list[DirectoryObject]] = None
     # The collection of password credentials associated with the application. Not nullable.
     password_credentials: Optional[list[PasswordCredential]] = None

msgraph/generated/models/time_card.py

@@ -0,0 +1,103 @@
+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 .change_tracked_entity import ChangeTrackedEntity
+    from .confirmed_by import ConfirmedBy
+    from .item_body import ItemBody
+    from .time_card_break import TimeCardBreak
+    from .time_card_entry import TimeCardEntry
+    from .time_card_event import TimeCardEvent
+    from .time_card_state import TimeCardState
+
+from .change_tracked_entity import ChangeTrackedEntity
+
+@dataclass
+class TimeCard(ChangeTrackedEntity, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.timeCard"
+    # The list of breaks associated with the timeCard.
+    breaks: Optional[list[TimeCardBreak]] = None
+    # The clock-in event of the timeCard.
+    clock_in_event: Optional[TimeCardEvent] = None
+    # The clock-out event of the timeCard.
+    clock_out_event: Optional[TimeCardEvent] = None
+    # Indicates whether this timeCard entry is confirmed. Possible values are: none, user, manager, unknownFutureValue.
+    confirmed_by: Optional[ConfirmedBy] = None
+    # Notes about the timeCard.
+    notes: Optional[ItemBody] = None
+    # The original timeCardEntry of the timeCard before it was edited.
+    original_entry: Optional[TimeCardEntry] = None
+    # The current state of the timeCard during its life cycle. The possible values are: clockedIn, onBreak, clockedOut, unknownFutureValue.
+    state: Optional[TimeCardState] = None
+    # User ID to which the timeCard belongs.
+    user_id: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> TimeCard:
+        """
+        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: TimeCard
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return TimeCard()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .change_tracked_entity import ChangeTrackedEntity
+        from .confirmed_by import ConfirmedBy
+        from .item_body import ItemBody
+        from .time_card_break import TimeCardBreak
+        from .time_card_entry import TimeCardEntry
+        from .time_card_event import TimeCardEvent
+        from .time_card_state import TimeCardState
+
+        from .change_tracked_entity import ChangeTrackedEntity
+        from .confirmed_by import ConfirmedBy
+        from .item_body import ItemBody
+        from .time_card_break import TimeCardBreak
+        from .time_card_entry import TimeCardEntry
+        from .time_card_event import TimeCardEvent
+        from .time_card_state import TimeCardState
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "breaks": lambda n : setattr(self, 'breaks', n.get_collection_of_object_values(TimeCardBreak)),
+            "clockInEvent": lambda n : setattr(self, 'clock_in_event', n.get_object_value(TimeCardEvent)),
+            "clockOutEvent": lambda n : setattr(self, 'clock_out_event', n.get_object_value(TimeCardEvent)),
+            "confirmedBy": lambda n : setattr(self, 'confirmed_by', n.get_collection_of_enum_values(ConfirmedBy)),
+            "notes": lambda n : setattr(self, 'notes', n.get_object_value(ItemBody)),
+            "originalEntry": lambda n : setattr(self, 'original_entry', n.get_object_value(TimeCardEntry)),
+            "state": lambda n : setattr(self, 'state', n.get_enum_value(TimeCardState)),
+            "userId": lambda n : setattr(self, 'user_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_collection_of_object_values("breaks", self.breaks)
+        writer.write_object_value("clockInEvent", self.clock_in_event)
+        writer.write_object_value("clockOutEvent", self.clock_out_event)
+        writer.write_enum_value("confirmedBy", self.confirmed_by)
+        writer.write_object_value("notes", self.notes)
+        writer.write_object_value("originalEntry", self.original_entry)
+        writer.write_enum_value("state", self.state)
+        writer.write_str_value("userId", self.user_id)
+    
+

msgraph/generated/models/time_card_break.py

@@ -0,0 +1,76 @@
+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 .item_body import ItemBody
+    from .time_card_event import TimeCardEvent
+
+@dataclass
+class TimeCardBreak(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)
+    # ID of the timeCardBreak.
+    break_id: Optional[str] = None
+    # The start event of the timeCardBreak.
+    end: Optional[TimeCardEvent] = None
+    # Notes about the timeCardBreak.
+    notes: Optional[ItemBody] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The start property
+    start: Optional[TimeCardEvent] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> TimeCardBreak:
+        """
+        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: TimeCardBreak
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return TimeCardBreak()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .item_body import ItemBody
+        from .time_card_event import TimeCardEvent
+
+        from .item_body import ItemBody
+        from .time_card_event import TimeCardEvent
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "breakId": lambda n : setattr(self, 'break_id', n.get_str_value()),
+            "end": lambda n : setattr(self, 'end', n.get_object_value(TimeCardEvent)),
+            "notes": lambda n : setattr(self, 'notes', n.get_object_value(ItemBody)),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "start": lambda n : setattr(self, 'start', n.get_object_value(TimeCardEvent)),
+        }
+        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("breakId", self.break_id)
+        writer.write_object_value("end", self.end)
+        writer.write_object_value("notes", self.notes)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_object_value("start", self.start)
+        writer.write_additional_data_value(self.additional_data)
+    
+

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

@@ -0,0 +1,72 @@
+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 .time_card_break import TimeCardBreak
+    from .time_card_event import TimeCardEvent
+
+@dataclass
+class TimeCardEntry(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 clock-in event of the timeCard.
+    breaks: Optional[list[TimeCardBreak]] = None
+    # The clock-out event of the timeCard.
+    clock_in_event: Optional[TimeCardEvent] = None
+    # The list of breaks associated with the timeCard.
+    clock_out_event: Optional[TimeCardEvent] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> TimeCardEntry:
+        """
+        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: TimeCardEntry
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return TimeCardEntry()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .time_card_break import TimeCardBreak
+        from .time_card_event import TimeCardEvent
+
+        from .time_card_break import TimeCardBreak
+        from .time_card_event import TimeCardEvent
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "breaks": lambda n : setattr(self, 'breaks', n.get_collection_of_object_values(TimeCardBreak)),
+            "clockInEvent": lambda n : setattr(self, 'clock_in_event', n.get_object_value(TimeCardEvent)),
+            "clockOutEvent": lambda n : setattr(self, 'clock_out_event', n.get_object_value(TimeCardEvent)),
+            "@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_collection_of_object_values("breaks", self.breaks)
+        writer.write_object_value("clockInEvent", self.clock_in_event)
+        writer.write_object_value("clockOutEvent", self.clock_out_event)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/{app_role_assignments/validate_properties/validate_properties_post_request_body.py → models/time_card_event.py}

@@ -1,48 +1,55 @@
 from __future__ import annotations
+import datetime
 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
-from uuid import UUID
+
+if TYPE_CHECKING:
+    from .item_body import ItemBody
 
 @dataclass
-class ValidatePropertiesPostRequestBody(AdditionalDataHolder, BackedModel, Parsable):
+class TimeCardEvent(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 entityType property
-    entity_type: Optional[str] = None
-    # The mailNickname property
-    mail_nickname: Optional[str] = None
-    # The onBehalfOfUserId property
-    on_behalf_of_user_id: Optional[UUID] = None
+    # The time the entry is recorded.
+    date_time: Optional[datetime.datetime] = None
+    # Indicates whether this action happens at an approved location.
+    is_at_approved_location: Optional[bool] = None
+    # Notes about the timeCardEvent.
+    notes: Optional[ItemBody] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
     
     @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> ValidatePropertiesPostRequestBody:
+    def create_from_discriminator_value(parse_node: ParseNode) -> TimeCardEvent:
         """
         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: ValidatePropertiesPostRequestBody
+        Returns: TimeCardEvent
         """
         if parse_node is None:
             raise TypeError("parse_node cannot be null.")
-        return ValidatePropertiesPostRequestBody()
+        return TimeCardEvent()
     
     def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
         """
         The deserialization information for the current model
         Returns: dict[str, Callable[[ParseNode], None]]
         """
+        from .item_body import ItemBody
+
+        from .item_body import ItemBody
+
         fields: dict[str, Callable[[Any], None]] = {
-            "displayName": lambda n : setattr(self, 'display_name', n.get_str_value()),
-            "entityType": lambda n : setattr(self, 'entity_type', n.get_str_value()),
-            "mailNickname": lambda n : setattr(self, 'mail_nickname', n.get_str_value()),
-            "onBehalfOfUserId": lambda n : setattr(self, 'on_behalf_of_user_id', n.get_uuid_value()),
+            "dateTime": lambda n : setattr(self, 'date_time', n.get_datetime_value()),
+            "isAtApprovedLocation": lambda n : setattr(self, 'is_at_approved_location', n.get_bool_value()),
+            "notes": lambda n : setattr(self, 'notes', n.get_object_value(ItemBody)),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
         }
         return fields
     
@@ -54,10 +61,10 @@ class ValidatePropertiesPostRequestBody(AdditionalDataHolder, BackedModel, Parsa
         """
         if writer is None:
             raise TypeError("writer cannot be null.")
-        writer.write_str_value("displayName", self.display_name)
-        writer.write_str_value("entityType", self.entity_type)
-        writer.write_str_value("mailNickname", self.mail_nickname)
-        writer.write_uuid_value("onBehalfOfUserId", self.on_behalf_of_user_id)
+        writer.write_datetime_value("dateTime", self.date_time)
+        writer.write_bool_value("isAtApprovedLocation", self.is_at_approved_location)
+        writer.write_object_value("notes", self.notes)
+        writer.write_str_value("@odata.type", self.odata_type)
         writer.write_additional_data_value(self.additional_data)
     
 

msgraph/generated/models/time_card_state.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class TimeCardState(str, Enum):
+    ClockedIn = "clockedIn",
+    OnBreak = "onBreak",
+    ClockedOut = "clockedOut",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/time_clock_settings.py

@@ -0,0 +1,61 @@
+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 .geo_coordinates import GeoCoordinates
+
+@dataclass
+class TimeClockSettings(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 approved location of the timeClock.
+    approved_location: Optional[GeoCoordinates] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> TimeClockSettings:
+        """
+        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: TimeClockSettings
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return TimeClockSettings()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .geo_coordinates import GeoCoordinates
+
+        from .geo_coordinates import GeoCoordinates
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "approvedLocation": lambda n : setattr(self, 'approved_location', n.get_object_value(GeoCoordinates)),
+            "@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_object_value("approvedLocation", self.approved_location)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/time_off_reason.py

@@ -14,6 +14,8 @@ from .change_tracked_entity import ChangeTrackedEntity
 class TimeOffReason(ChangeTrackedEntity, Parsable):
     # The OdataType property
     odata_type: Optional[str] = "#microsoft.graph.timeOffReason"
+    # The code of the timeOffReason to represent an external identifier. This field must be unique within the team in Microsoft Teams and uses an alphanumeric format, with a maximum of 100 characters.
+    code: Optional[str] = None
     # The name of the timeOffReason. Required.
     display_name: Optional[str] = None
     # Supported icon types are: none, car, calendar, running, plane, firstAid, doctor, notWorking, clock, juryDuty, globe, cup, phone, weather, umbrella, piggyBank, dog, cake, trafficCone, pin, sunny. Required.
@@ -44,6 +46,7 @@ class TimeOffReason(ChangeTrackedEntity, Parsable):
         from .time_off_reason_icon_type import TimeOffReasonIconType
 
         fields: dict[str, Callable[[Any], None]] = {
+            "code": lambda n : setattr(self, 'code', n.get_str_value()),
             "displayName": lambda n : setattr(self, 'display_name', n.get_str_value()),
             "iconType": lambda n : setattr(self, 'icon_type', n.get_enum_value(TimeOffReasonIconType)),
             "isActive": lambda n : setattr(self, 'is_active', n.get_bool_value()),
@@ -61,6 +64,7 @@ class TimeOffReason(ChangeTrackedEntity, Parsable):
         if writer is None:
             raise TypeError("writer cannot be null.")
         super().serialize(writer)
+        writer.write_str_value("code", self.code)
         writer.write_str_value("displayName", self.display_name)
         writer.write_enum_value("iconType", self.icon_type)
         writer.write_bool_value("isActive", self.is_active)

msgraph/generated/models/user.py

@@ -116,7 +116,7 @@ class User(DirectoryObject, Parsable):
     contact_folders: Optional[list[ContactFolder]] = None
     # The user's contacts. Read-only. Nullable.
     contacts: Optional[list[Contact]] = None
-    # The country/region where the user is located; for example, US or UK. Maximum length is 128 characters. Returned only on $select. Supports $filter (eq, ne, not, ge, le, in, startsWith, and eq on null values).
+    # The country or region where the user is located; for example, US or UK. Maximum length is 128 characters. Returned only on $select. Supports $filter (eq, ne, not, ge, le, in, startsWith, and eq on null values).
     country: Optional[str] = None
     # The date and time the user was created, in ISO 8601 format and UTC. The value can't be modified and is automatically populated when the entity is created. Nullable. For on-premises users, the value represents when they were first created in Microsoft Entra ID. Property is null for some users created before June 2018 and on-premises users that were synced to Microsoft Entra ID before June 2018. Read-only. Returned only on $select. Supports $filter (eq, ne, not , ge, le, in).
     created_date_time: Optional[datetime.datetime] = None
@@ -268,7 +268,7 @@ class User(DirectoryObject, Parsable):
     photos: Optional[list[ProfilePhoto]] = None
     # Entry-point to the Planner resource that might exist for a user. Read-only.
     planner: Optional[PlannerUser] = None
-    # The postal code for the user's postal address. The postal code is specific to the user's country/region. In the United States of America, this attribute contains the ZIP code. Maximum length is 40 characters. Returned only on $select. Supports $filter (eq, ne, not, ge, le, in, startsWith, and eq on null values).
+    # The postal code for the user's postal address. The postal code is specific to the user's country or region. In the United States of America, this attribute contains the ZIP code. Maximum length is 40 characters. Returned only on $select. Supports $filter (eq, ne, not, ge, le, in, startsWith, and eq on null values).
     postal_code: Optional[str] = None
     # The preferred data location for the user. For more information, see OneDrive Online Multi-Geo.
     preferred_data_location: Optional[str] = None
@@ -322,7 +322,7 @@ class User(DirectoryObject, Parsable):
     todo: Optional[Todo] = None
     # The groups, including nested groups, and directory roles that a user is a member of. Nullable.
     transitive_member_of: Optional[list[DirectoryObject]] = None
-    # A two-letter country code (ISO standard 3166). Required for users that are assigned licenses due to legal requirements to check for availability of services in countries. Examples include: US, JP, and GB. Not nullable. Returned only on $select. Supports $filter (eq, ne, not, ge, le, in, startsWith, and eq on null values).
+    # A two-letter country code (ISO standard 3166). Required for users that are assigned licenses due to legal requirements to check for availability of services in countries/regions. Examples include: US, JP, and GB. Not nullable. Returned only on $select. Supports $filter (eq, ne, not, ge, le, in, startsWith, and eq on null values).
     usage_location: Optional[str] = None
     # The user principal name (UPN) of the user. The UPN is an Internet-style sign-in name for the user based on the Internet standard RFC 822. By convention, this value should map to the user's email name. The general format is alias@domain, where the domain must be present in the tenant's collection of verified domains. This property is required when a user is created. The verified domains for the tenant can be accessed from the verifiedDomains property of organization.NOTE: This property can't contain accent characters. Only the following characters are allowed A - Z, a - z, 0 - 9, ' . - _ ! # ^ ~. For the complete list of allowed characters, see username policies. Returned by default. Supports $filter (eq, ne, not, ge, le, in, startsWith, endsWith) and $orderby.
     user_principal_name: Optional[str] = None

msgraph/generated/models/workbook_worksheet_protection_options.py

@@ -12,27 +12,27 @@ class WorkbookWorksheetProtectionOptions(AdditionalDataHolder, BackedModel, Pars
 
     # 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)
-    # Represents the worksheet protection option of allowing using auto filter feature.
+    # Indicates whether the worksheet protection option to allow the use of the autofilter feature is enabled.
     allow_auto_filter: Optional[bool] = None
-    # Represents the worksheet protection option of allowing deleting columns.
+    # Indicates whether the worksheet protection option to allow deleting columns is enabled.
     allow_delete_columns: Optional[bool] = None
-    # Represents the worksheet protection option of allowing deleting rows.
+    # Indicates whether the worksheet protection option to allow deleting rows is enabled.
     allow_delete_rows: Optional[bool] = None
-    # Represents the worksheet protection option of allowing formatting cells.
+    # Indicates whether the worksheet protection option to allow formatting cells is enabled.
     allow_format_cells: Optional[bool] = None
-    # Represents the worksheet protection option of allowing formatting columns.
+    # Indicates whether the worksheet protection option to allow formatting columns is enabled.
     allow_format_columns: Optional[bool] = None
-    # Represents the worksheet protection option of allowing formatting rows.
+    # Indicates whether the worksheet protection option to allow formatting rows is enabled.
     allow_format_rows: Optional[bool] = None
-    # Represents the worksheet protection option of allowing inserting columns.
+    # Indicates whether the worksheet protection option to allow inserting columns is enabled.
     allow_insert_columns: Optional[bool] = None
-    # Represents the worksheet protection option of allowing inserting hyperlinks.
+    # Indicates whether the worksheet protection option to allow inserting hyperlinks is enabled.
     allow_insert_hyperlinks: Optional[bool] = None
-    # Represents the worksheet protection option of allowing inserting rows.
+    # Indicates whether the worksheet protection option to allow inserting rows is enabled.
     allow_insert_rows: Optional[bool] = None
-    # Represents the worksheet protection option of allowing using pivot table feature.
+    # Indicates whether the worksheet protection option to allow the use of the pivot table feature is enabled.
     allow_pivot_tables: Optional[bool] = None
-    # Represents the worksheet protection option of allowing using sort feature.
+    # Indicates whether the worksheet protection option to allow the use of the sort feature is enabled.
     allow_sort: Optional[bool] = None
     # The OdataType property
     odata_type: Optional[str] = None

msgraph/generated/models/workforce_integration_supported_entities.py

@@ -9,6 +9,7 @@ class WorkforceIntegrationSupportedEntities(str, Enum):
     OpenShiftRequest = "openShiftRequest",
     OfferShiftRequest = "offerShiftRequest",
     UnknownFutureValue = "unknownFutureValue",
+    TimeCard = "timeCard",
     TimeOffReason = "timeOffReason",
     TimeOff = "timeOff",
     TimeOffRequest = "timeOffRequest",

msgraph/generated/organization/item/organization_item_request_builder.py

@@ -80,11 +80,11 @@ class OrganizationItemRequestBuilder(BaseRequestBuilder):
     
     async def patch(self,body: Organization, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[Organization]:
         """
-        Update the properties of the currently authenticated organization. In this case, organization is defined as a collection of exactly one record, and so its ID must be specified in the request.  The ID is also known as the tenantId of the organization.
+        Update the properties of a organization object.
         param body: The request body
         param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
         Returns: Optional[Organization]
-        Find more info here: https://learn.microsoft.com/graph/api/organization-update?view=graph-rest-1.0
+        Find more info here: https://learn.microsoft.com/graph/api/intune-onboarding-organization-update?view=graph-rest-1.0
         """
         if body is None:
             raise TypeError("body cannot be null.")
@@ -126,7 +126,7 @@ class OrganizationItemRequestBuilder(BaseRequestBuilder):
     
     def to_patch_request_information(self,body: Organization, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation:
         """
-        Update the properties of the currently authenticated organization. In this case, organization is defined as a collection of exactly one record, and so its ID must be specified in the request.  The ID is also known as the tenantId of the organization.
+        Update the properties of a organization object.
         param body: The request body
         param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
         Returns: RequestInformation

msgraph/generated/policies/cross_tenant_access_policy/partners/item/identity_synchronization/identity_synchronization_request_builder.py

@@ -72,11 +72,11 @@ class IdentitySynchronizationRequestBuilder(BaseRequestBuilder):
     
     async def put(self,body: CrossTenantIdentitySyncPolicyPartner, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[CrossTenantIdentitySyncPolicyPartner]:
         """
-        Update the user synchronization policy of a partner-specific configuration.
+        Create a cross-tenant user synchronization policy for a partner-specific configuration.
         param body: The request body
         param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
         Returns: Optional[CrossTenantIdentitySyncPolicyPartner]
-        Find more info here: https://learn.microsoft.com/graph/api/crosstenantidentitysyncpolicypartner-update?view=graph-rest-1.0
+        Find more info here: https://learn.microsoft.com/graph/api/crosstenantaccesspolicyconfigurationpartner-put-identitysynchronization?view=graph-rest-1.0
         """
         if body is None:
             raise TypeError("body cannot be null.")
@@ -118,7 +118,7 @@ class IdentitySynchronizationRequestBuilder(BaseRequestBuilder):
     
     def to_put_request_information(self,body: CrossTenantIdentitySyncPolicyPartner, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation:
         """
-        Update the user synchronization policy of a partner-specific configuration.
+        Create a cross-tenant user synchronization policy for a partner-specific configuration.
         param body: The request body
         param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
         Returns: RequestInformation