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

msgraph/generated/models/human_security_fraud_protection_provider.py

@@ -0,0 +1,61 @@
+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 .fraud_protection_provider import FraudProtectionProvider
+
+from .fraud_protection_provider import FraudProtectionProvider
+
+@dataclass
+class HumanSecurityFraudProtectionProvider(FraudProtectionProvider, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.humanSecurityFraudProtectionProvider"
+    # Unique identifier for an individual application. You can retrieve this from the HUMAN Security Admin Console or request it from your HUMAN Security Customer Success Manager.
+    app_id: Optional[str] = None
+    # Unique identifier used to authenticate API calls between the Server side integration and the HUMAN platform. You can retrieve this from the HUMAN Security Admin Console or request it from your HUMAN Security Customer Success Manager.
+    server_token: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> HumanSecurityFraudProtectionProvider:
+        """
+        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: HumanSecurityFraudProtectionProvider
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return HumanSecurityFraudProtectionProvider()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .fraud_protection_provider import FraudProtectionProvider
+
+        from .fraud_protection_provider import FraudProtectionProvider
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "appId": lambda n : setattr(self, 'app_id', n.get_str_value()),
+            "serverToken": lambda n : setattr(self, 'server_token', n.get_str_value()),
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+        writer.write_str_value("appId", self.app_id)
+        writer.write_str_value("serverToken", self.server_token)
+    
+

msgraph/generated/models/identity_container.py

@@ -36,7 +36,7 @@ class IdentityContainer(Entity, Parsable):
     identity_providers: Optional[list[IdentityProviderBase]] = None
     # The OdataType property
     odata_type: Optional[str] = None
-    # The riskPrevention property
+    # Represents the entry point for fraud and risk prevention configurations in Microsoft Entra External ID, including third-party provider settings.
     risk_prevention: Optional[RiskPreventionContainer] = None
     # Represents entry point for identity userflow attributes.
     user_flow_attributes: Optional[list[IdentityUserFlowAttribute]] = None

msgraph/generated/models/identity_governance/activate_group_scope.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from ..group import Group
+    from .activation_scope import ActivationScope
+
+from .activation_scope import ActivationScope
+
+@dataclass
+class ActivateGroupScope(ActivationScope, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.identityGovernance.activateGroupScope"
+    # The group property
+    group: Optional[Group] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ActivateGroupScope:
+        """
+        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: ActivateGroupScope
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ActivateGroupScope()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from ..group import Group
+        from .activation_scope import ActivationScope
+
+        from ..group import Group
+        from .activation_scope import ActivationScope
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "group": lambda n : setattr(self, 'group', n.get_object_value(Group)),
+        }
+        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("group", self.group)
+    
+

msgraph/generated/models/identity_governance/activate_processing_result_scope.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 .activation_scope import ActivationScope
+    from .activation_task_scope_type import ActivationTaskScopeType
+    from .user_processing_result import UserProcessingResult
+
+from .activation_scope import ActivationScope
+
+@dataclass
+class ActivateProcessingResultScope(ActivationScope, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.identityGovernance.activateProcessingResultScope"
+    # The processingResults property
+    processing_results: Optional[list[UserProcessingResult]] = None
+    # The taskScope property
+    task_scope: Optional[ActivationTaskScopeType] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ActivateProcessingResultScope:
+        """
+        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: ActivateProcessingResultScope
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ActivateProcessingResultScope()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .activation_scope import ActivationScope
+        from .activation_task_scope_type import ActivationTaskScopeType
+        from .user_processing_result import UserProcessingResult
+
+        from .activation_scope import ActivationScope
+        from .activation_task_scope_type import ActivationTaskScopeType
+        from .user_processing_result import UserProcessingResult
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "processingResults": lambda n : setattr(self, 'processing_results', n.get_collection_of_object_values(UserProcessingResult)),
+            "taskScope": lambda n : setattr(self, 'task_scope', n.get_enum_value(ActivationTaskScopeType)),
+        }
+        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("processingResults", self.processing_results)
+        writer.write_enum_value("taskScope", self.task_scope)
+    
+

msgraph/generated/models/identity_governance/activate_run_scope.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 .activation_scope import ActivationScope
+    from .activation_task_scope_type import ActivationTaskScopeType
+    from .activation_user_scope_type import ActivationUserScopeType
+    from .run import Run
+
+from .activation_scope import ActivationScope
+
+@dataclass
+class ActivateRunScope(ActivationScope, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.identityGovernance.activateRunScope"
+    # The run property
+    run: Optional[Run] = None
+    # The taskScope property
+    task_scope: Optional[ActivationTaskScopeType] = None
+    # The userScope property
+    user_scope: Optional[ActivationUserScopeType] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ActivateRunScope:
+        """
+        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: ActivateRunScope
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ActivateRunScope()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .activation_scope import ActivationScope
+        from .activation_task_scope_type import ActivationTaskScopeType
+        from .activation_user_scope_type import ActivationUserScopeType
+        from .run import Run
+
+        from .activation_scope import ActivationScope
+        from .activation_task_scope_type import ActivationTaskScopeType
+        from .activation_user_scope_type import ActivationUserScopeType
+        from .run import Run
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "run": lambda n : setattr(self, 'run', n.get_object_value(Run)),
+            "taskScope": lambda n : setattr(self, 'task_scope', n.get_enum_value(ActivationTaskScopeType)),
+            "userScope": lambda n : setattr(self, 'user_scope', n.get_enum_value(ActivationUserScopeType)),
+        }
+        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("run", self.run)
+        writer.write_enum_value("taskScope", self.task_scope)
+        writer.write_enum_value("userScope", self.user_scope)
+    
+

msgraph/generated/models/identity_governance/activate_user_scope.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from ..user import User
+    from .activation_scope import ActivationScope
+
+from .activation_scope import ActivationScope
+
+@dataclass
+class ActivateUserScope(ActivationScope, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.identityGovernance.activateUserScope"
+    # The users property
+    users: Optional[list[User]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ActivateUserScope:
+        """
+        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: ActivateUserScope
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ActivateUserScope()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from ..user import User
+        from .activation_scope import ActivationScope
+
+        from ..user import User
+        from .activation_scope import ActivationScope
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "users": lambda n : setattr(self, 'users', n.get_collection_of_object_values(User)),
+        }
+        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("users", self.users)
+    
+

msgraph/generated/models/identity_governance/activation_scope.py

@@ -0,0 +1,87 @@
+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 .activate_group_scope import ActivateGroupScope
+    from .activate_processing_result_scope import ActivateProcessingResultScope
+    from .activate_run_scope import ActivateRunScope
+    from .activate_user_scope import ActivateUserScope
+
+@dataclass
+class ActivationScope(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 OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ActivationScope:
+        """
+        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: ActivationScope
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        try:
+            child_node = parse_node.get_child_node("@odata.type")
+            mapping_value = child_node.get_str_value() if child_node else None
+        except AttributeError:
+            mapping_value = None
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.identityGovernance.activateGroupScope".casefold():
+            from .activate_group_scope import ActivateGroupScope
+
+            return ActivateGroupScope()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.identityGovernance.activateProcessingResultScope".casefold():
+            from .activate_processing_result_scope import ActivateProcessingResultScope
+
+            return ActivateProcessingResultScope()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.identityGovernance.activateRunScope".casefold():
+            from .activate_run_scope import ActivateRunScope
+
+            return ActivateRunScope()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.identityGovernance.activateUserScope".casefold():
+            from .activate_user_scope import ActivateUserScope
+
+            return ActivateUserScope()
+        return ActivationScope()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .activate_group_scope import ActivateGroupScope
+        from .activate_processing_result_scope import ActivateProcessingResultScope
+        from .activate_run_scope import ActivateRunScope
+        from .activate_user_scope import ActivateUserScope
+
+        from .activate_group_scope import ActivateGroupScope
+        from .activate_processing_result_scope import ActivateProcessingResultScope
+        from .activate_run_scope import ActivateRunScope
+        from .activate_user_scope import ActivateUserScope
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/identity_governance/activation_task_scope_type.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class ActivationTaskScopeType(str, Enum):
+    AllTasks = "allTasks",
+    FailedTasks = "failedTasks",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/identity_governance/activation_user_scope_type.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class ActivationUserScopeType(str, Enum):
+    AllUsers = "allUsers",
+    FailedUsers = "failedUsers",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/identity_governance/run.py

@@ -7,6 +7,7 @@ from typing import Any, Optional, TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
     from ..entity import Entity
+    from .activation_scope import ActivationScope
     from .lifecycle_workflow_processing_status import LifecycleWorkflowProcessingStatus
     from .task_processing_result import TaskProcessingResult
     from .user_processing_result import UserProcessingResult
@@ -16,6 +17,8 @@ from ..entity import Entity
 
 @dataclass
 class Run(Entity, Parsable):
+    # The scope for which the workflow runs.
+    activated_on_scope: Optional[ActivationScope] = None
     # The date time that the run completed. Value is null if the workflow hasn't completed.Supports $filter(lt, le, gt, ge, eq, ne) and $orderby.
     completed_date_time: Optional[datetime.datetime] = None
     # The number of tasks that failed in the run execution.
@@ -28,6 +31,8 @@ class Run(Entity, Parsable):
     odata_type: Optional[str] = None
     # The processingStatus property
     processing_status: Optional[LifecycleWorkflowProcessingStatus] = None
+    # The related reprocessed workflow run.
+    reprocessed_runs: Optional[list[Run]] = None
     # The date time that the run is scheduled to be executed for a workflow.Supports $filter(lt, le, gt, ge, eq, ne) and $orderby.
     scheduled_date_time: Optional[datetime.datetime] = None
     # The date time that the run execution started.Supports $filter(lt, le, gt, ge, eq, ne) and $orderby.
@@ -64,23 +69,27 @@ class Run(Entity, Parsable):
         Returns: dict[str, Callable[[ParseNode], None]]
         """
         from ..entity import Entity
+        from .activation_scope import ActivationScope
         from .lifecycle_workflow_processing_status import LifecycleWorkflowProcessingStatus
         from .task_processing_result import TaskProcessingResult
         from .user_processing_result import UserProcessingResult
         from .workflow_execution_type import WorkflowExecutionType
 
         from ..entity import Entity
+        from .activation_scope import ActivationScope
         from .lifecycle_workflow_processing_status import LifecycleWorkflowProcessingStatus
         from .task_processing_result import TaskProcessingResult
         from .user_processing_result import UserProcessingResult
         from .workflow_execution_type import WorkflowExecutionType
 
         fields: dict[str, Callable[[Any], None]] = {
+            "activatedOnScope": lambda n : setattr(self, 'activated_on_scope', n.get_object_value(ActivationScope)),
             "completedDateTime": lambda n : setattr(self, 'completed_date_time', n.get_datetime_value()),
             "failedTasksCount": lambda n : setattr(self, 'failed_tasks_count', n.get_int_value()),
             "failedUsersCount": lambda n : setattr(self, 'failed_users_count', n.get_int_value()),
             "lastUpdatedDateTime": lambda n : setattr(self, 'last_updated_date_time', n.get_datetime_value()),
             "processingStatus": lambda n : setattr(self, 'processing_status', n.get_enum_value(LifecycleWorkflowProcessingStatus)),
+            "reprocessedRuns": lambda n : setattr(self, 'reprocessed_runs', n.get_collection_of_object_values(Run)),
             "scheduledDateTime": lambda n : setattr(self, 'scheduled_date_time', n.get_datetime_value()),
             "startedDateTime": lambda n : setattr(self, 'started_date_time', n.get_datetime_value()),
             "successfulUsersCount": lambda n : setattr(self, 'successful_users_count', n.get_int_value()),
@@ -104,11 +113,13 @@ class Run(Entity, Parsable):
         if writer is None:
             raise TypeError("writer cannot be null.")
         super().serialize(writer)
+        writer.write_object_value("activatedOnScope", self.activated_on_scope)
         writer.write_datetime_value("completedDateTime", self.completed_date_time)
         writer.write_int_value("failedTasksCount", self.failed_tasks_count)
         writer.write_int_value("failedUsersCount", self.failed_users_count)
         writer.write_datetime_value("lastUpdatedDateTime", self.last_updated_date_time)
         writer.write_enum_value("processingStatus", self.processing_status)
+        writer.write_collection_of_object_values("reprocessedRuns", self.reprocessed_runs)
         writer.write_datetime_value("scheduledDateTime", self.scheduled_date_time)
         writer.write_datetime_value("startedDateTime", self.started_date_time)
         writer.write_int_value("successfulUsersCount", self.successful_users_count)

msgraph/generated/models/identity_governance/user_inactivity_trigger.py

@@ -0,0 +1,57 @@
+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 .workflow_execution_trigger import WorkflowExecutionTrigger
+
+from .workflow_execution_trigger import WorkflowExecutionTrigger
+
+@dataclass
+class UserInactivityTrigger(WorkflowExecutionTrigger, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.identityGovernance.userInactivityTrigger"
+    # The number of days a user must be inactive before triggering workflow execution.
+    inactivity_period_in_days: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserInactivityTrigger:
+        """
+        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: UserInactivityTrigger
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserInactivityTrigger()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .workflow_execution_trigger import WorkflowExecutionTrigger
+
+        from .workflow_execution_trigger import WorkflowExecutionTrigger
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "inactivityPeriodInDays": lambda n : setattr(self, 'inactivity_period_in_days', n.get_int_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_int_value("inactivityPeriodInDays", self.inactivity_period_in_days)
+    
+

msgraph/generated/models/identity_governance/user_processing_result.py

@@ -9,6 +9,7 @@ if TYPE_CHECKING:
     from ..entity import Entity
     from ..user import User
     from .lifecycle_workflow_processing_status import LifecycleWorkflowProcessingStatus
+    from .run import Run
     from .task_processing_result import TaskProcessingResult
     from .workflow_execution_type import WorkflowExecutionType
 
@@ -24,9 +25,11 @@ class UserProcessingResult(Entity, Parsable):
     odata_type: Optional[str] = None
     # The processingStatus property
     processing_status: Optional[LifecycleWorkflowProcessingStatus] = None
+    # The related reprocessed workflow run.
+    reprocessed_runs: Optional[list[Run]] = None
     # The date time that the workflow is scheduled to be executed for a user.Supports $filter(lt, le, gt, ge, eq, ne) and $orderby.
     scheduled_date_time: Optional[datetime.datetime] = None
-    # The date time that the workflow execution started. Value is null if the workflow execution has not started.Supports $filter(lt, le, gt, ge, eq, ne) and $orderby.
+    # The date time that the workflow execution started. Value is null if the workflow execution hasn't started.Supports $filter(lt, le, gt, ge, eq, ne) and $orderby.
     started_date_time: Optional[datetime.datetime] = None
     # The subject property
     subject: Optional[User] = None
@@ -60,12 +63,14 @@ class UserProcessingResult(Entity, Parsable):
         from ..entity import Entity
         from ..user import User
         from .lifecycle_workflow_processing_status import LifecycleWorkflowProcessingStatus
+        from .run import Run
         from .task_processing_result import TaskProcessingResult
         from .workflow_execution_type import WorkflowExecutionType
 
         from ..entity import Entity
         from ..user import User
         from .lifecycle_workflow_processing_status import LifecycleWorkflowProcessingStatus
+        from .run import Run
         from .task_processing_result import TaskProcessingResult
         from .workflow_execution_type import WorkflowExecutionType
 
@@ -73,6 +78,7 @@ class UserProcessingResult(Entity, Parsable):
             "completedDateTime": lambda n : setattr(self, 'completed_date_time', n.get_datetime_value()),
             "failedTasksCount": lambda n : setattr(self, 'failed_tasks_count', n.get_int_value()),
             "processingStatus": lambda n : setattr(self, 'processing_status', n.get_enum_value(LifecycleWorkflowProcessingStatus)),
+            "reprocessedRuns": lambda n : setattr(self, 'reprocessed_runs', n.get_collection_of_object_values(Run)),
             "scheduledDateTime": lambda n : setattr(self, 'scheduled_date_time', n.get_datetime_value()),
             "startedDateTime": lambda n : setattr(self, 'started_date_time', n.get_datetime_value()),
             "subject": lambda n : setattr(self, 'subject', n.get_object_value(User)),
@@ -98,6 +104,7 @@ class UserProcessingResult(Entity, Parsable):
         writer.write_datetime_value("completedDateTime", self.completed_date_time)
         writer.write_int_value("failedTasksCount", self.failed_tasks_count)
         writer.write_enum_value("processingStatus", self.processing_status)
+        writer.write_collection_of_object_values("reprocessedRuns", self.reprocessed_runs)
         writer.write_datetime_value("scheduledDateTime", self.scheduled_date_time)
         writer.write_datetime_value("startedDateTime", self.started_date_time)
         writer.write_object_value("subject", self.subject)

msgraph/generated/models/identity_governance/workflow_execution_trigger.py

@@ -9,6 +9,7 @@ if TYPE_CHECKING:
     from .attribute_change_trigger import AttributeChangeTrigger
     from .membership_change_trigger import MembershipChangeTrigger
     from .time_based_attribute_trigger import TimeBasedAttributeTrigger
+    from .user_inactivity_trigger import UserInactivityTrigger
 
 @dataclass
 class WorkflowExecutionTrigger(AdditionalDataHolder, BackedModel, Parsable):
@@ -46,6 +47,10 @@ class WorkflowExecutionTrigger(AdditionalDataHolder, BackedModel, Parsable):
             from .time_based_attribute_trigger import TimeBasedAttributeTrigger
 
             return TimeBasedAttributeTrigger()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.identityGovernance.userInactivityTrigger".casefold():
+            from .user_inactivity_trigger import UserInactivityTrigger
+
+            return UserInactivityTrigger()
         return WorkflowExecutionTrigger()
     
     def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
@@ -56,10 +61,12 @@ class WorkflowExecutionTrigger(AdditionalDataHolder, BackedModel, Parsable):
         from .attribute_change_trigger import AttributeChangeTrigger
         from .membership_change_trigger import MembershipChangeTrigger
         from .time_based_attribute_trigger import TimeBasedAttributeTrigger
+        from .user_inactivity_trigger import UserInactivityTrigger
 
         from .attribute_change_trigger import AttributeChangeTrigger
         from .membership_change_trigger import MembershipChangeTrigger
         from .time_based_attribute_trigger import TimeBasedAttributeTrigger
+        from .user_inactivity_trigger import UserInactivityTrigger
 
         fields: dict[str, Callable[[Any], None]] = {
             "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),

msgraph/generated/models/identity_governance/workflow_execution_type.py

@@ -4,4 +4,5 @@ class WorkflowExecutionType(str, Enum):
     Scheduled = "scheduled",
     OnDemand = "onDemand",
     UnknownFutureValue = "unknownFutureValue",
+    ActivatedWithScope = "activatedWithScope",