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

msgraph/generated/models/security/ai_agent_evidence.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .ai_agent_platform import AiAgentPlatform
+    from .alert_evidence import AlertEvidence
+
+from .alert_evidence import AlertEvidence
+
+@dataclass
+class AiAgentEvidence(AlertEvidence, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.aiAgentEvidence"
+    # The unique identifier for the AI agent.
+    agent_id: Optional[str] = None
+    # The display name for the AI agent.
+    agent_name: Optional[str] = None
+    # Type of the platform the agent runs on. Possible values are: unknown, azureAIFoundry, copilotStudio, copilot, unknownFutureValue.
+    hosting_platform_type: Optional[AiAgentPlatform] = None
+    # The instructions of the agent.
+    instructions: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AiAgentEvidence:
+        """
+        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: AiAgentEvidence
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AiAgentEvidence()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .ai_agent_platform import AiAgentPlatform
+        from .alert_evidence import AlertEvidence
+
+        from .ai_agent_platform import AiAgentPlatform
+        from .alert_evidence import AlertEvidence
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "agentId": lambda n : setattr(self, 'agent_id', n.get_str_value()),
+            "agentName": lambda n : setattr(self, 'agent_name', n.get_str_value()),
+            "hostingPlatformType": lambda n : setattr(self, 'hosting_platform_type', n.get_enum_value(AiAgentPlatform)),
+            "instructions": lambda n : setattr(self, 'instructions', 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("agentId", self.agent_id)
+        writer.write_str_value("agentName", self.agent_name)
+        writer.write_enum_value("hostingPlatformType", self.hosting_platform_type)
+        writer.write_str_value("instructions", self.instructions)
+    
+

msgraph/generated/models/security/ai_agent_platform.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class AiAgentPlatform(str, Enum):
+    Unknown = "unknown",
+    AzureAIFoundry = "azureAIFoundry",
+    CopilotStudio = "copilotStudio",
+    Copilot = "copilot",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/security/alert_evidence.py

@@ -7,6 +7,7 @@ from kiota_abstractions.store import BackedModel, BackingStore, BackingStoreFact
 from typing import Any, Optional, TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
+    from .ai_agent_evidence import AiAgentEvidence
     from .amazon_resource_evidence import AmazonResourceEvidence
     from .analyzed_message_evidence import AnalyzedMessageEvidence
     from .azure_resource_evidence import AzureResourceEvidence
@@ -95,6 +96,10 @@ class AlertEvidence(AdditionalDataHolder, BackedModel, Parsable):
             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.security.aiAgentEvidence".casefold():
+            from .ai_agent_evidence import AiAgentEvidence
+
+            return AiAgentEvidence()
         if mapping_value and mapping_value.casefold() == "#microsoft.graph.security.amazonResourceEvidence".casefold():
             from .amazon_resource_evidence import AmazonResourceEvidence
 
@@ -286,6 +291,7 @@ class AlertEvidence(AdditionalDataHolder, BackedModel, Parsable):
         The deserialization information for the current model
         Returns: dict[str, Callable[[ParseNode], None]]
         """
+        from .ai_agent_evidence import AiAgentEvidence
         from .amazon_resource_evidence import AmazonResourceEvidence
         from .analyzed_message_evidence import AnalyzedMessageEvidence
         from .azure_resource_evidence import AzureResourceEvidence
@@ -336,6 +342,7 @@ class AlertEvidence(AdditionalDataHolder, BackedModel, Parsable):
         from .url_evidence import UrlEvidence
         from .user_evidence import UserEvidence
 
+        from .ai_agent_evidence import AiAgentEvidence
         from .amazon_resource_evidence import AmazonResourceEvidence
         from .analyzed_message_evidence import AnalyzedMessageEvidence
         from .azure_resource_evidence import AzureResourceEvidence

msgraph/generated/models/security/ediscovery_export_operation.py

@@ -22,7 +22,7 @@ class EdiscoveryExportOperation(CaseOperation, Parsable):
     export_file_metadata: Optional[list[ExportFileMetadata]] = None
     # The options provided for the export. For more information, see reviewSet: export. Possible values are: originalFiles, text, pdfReplacement, tags, unknownFutureValue, splitSource, includeFolderAndPath, friendlyName, condensePaths. Use the Prefer: include-unknown-enum-members request header to get the following values from this evolvable enum: splitSource, includeFolderAndPath, friendlyName, condensePaths.
     export_options: Optional[ExportOptions] = None
-    # The options that specify the structure of the export. For more information, see reviewSet: export. Possible values are: none, directory (deprecated), pst, unknownFutureValue, msg. Use the Prefer: include-unknown-enum-members request header to get the following value from this evolvable enum: msg. The directory member is deprecated. It remains in v1.0 for backward compatibility. Going forward, use either pst or msg.
+    # The options that specify the structure of the export. For more information, see reviewSet: export. Possible values are: none, directory (deprecated), pst, unknownFutureValue, msg. Use the Prefer: include-unknown-enum-members request header to get the following members from this evolvable enum: msg. The directory member is deprecated. It remains in v1.0 for backward compatibility. Going forward, use either pst or msg.
     export_structure: Optional[ExportFileStructure] = None
     # The OdataType property
     odata_type: Optional[str] = None

msgraph/generated/models/security/identity_accounts.py

@@ -0,0 +1,92 @@
+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 .account import Account
+    from .user import User
+
+from ..entity import Entity
+
+@dataclass
+class IdentityAccounts(Entity, Parsable):
+    # Collection of accounts of the identity in different identity providers.
+    accounts: Optional[list[Account]] = None
+    # The cloud security identifier of the identityAccount.
+    cloud_security_identifier: Optional[str] = None
+    # The  Active Directory display name of the identityAccount.
+    display_name: Optional[str] = None
+    # The Active Directory domain name of the identityAccount.
+    domain: Optional[str] = None
+    # Boolean indicating if the identityAccounts is enabled.
+    is_enabled: Optional[bool] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The on-premises security identifier of the identityAccount.
+    on_premises_security_identifier: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> IdentityAccounts:
+        """
+        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: IdentityAccounts
+        """
+        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.security.user".casefold():
+            from .user import User
+
+            return User()
+        return IdentityAccounts()
+    
+    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 .account import Account
+        from .user import User
+
+        from ..entity import Entity
+        from .account import Account
+        from .user import User
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "accounts": lambda n : setattr(self, 'accounts', n.get_collection_of_object_values(Account)),
+            "cloudSecurityIdentifier": lambda n : setattr(self, 'cloud_security_identifier', n.get_str_value()),
+            "displayName": lambda n : setattr(self, 'display_name', n.get_str_value()),
+            "domain": lambda n : setattr(self, 'domain', n.get_str_value()),
+            "isEnabled": lambda n : setattr(self, 'is_enabled', n.get_bool_value()),
+            "onPremisesSecurityIdentifier": lambda n : setattr(self, 'on_premises_security_identifier', 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("accounts", self.accounts)
+        writer.write_str_value("cloudSecurityIdentifier", self.cloud_security_identifier)
+        writer.write_str_value("displayName", self.display_name)
+        writer.write_str_value("domain", self.domain)
+        writer.write_bool_value("isEnabled", self.is_enabled)
+        writer.write_str_value("onPremisesSecurityIdentifier", self.on_premises_security_identifier)
+    
+

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

@@ -7,7 +7,10 @@ from typing import Any, Optional, TYPE_CHECKING, Union
 if TYPE_CHECKING:
     from ..entity import Entity
     from .health_issue import HealthIssue
+    from .identity_accounts import IdentityAccounts
     from .sensor import Sensor
+    from .sensor_candidate import SensorCandidate
+    from .sensor_candidate_activation_configuration import SensorCandidateActivationConfiguration
 
 from ..entity import Entity
 
@@ -15,8 +18,14 @@ from ..entity import Entity
 class IdentityContainer(Entity, Parsable):
     # Represents potential issues identified by Microsoft Defender for Identity within a customer's Microsoft Defender for Identity configuration.
     health_issues: Optional[list[HealthIssue]] = None
+    # Represents an identity's details in the context of Microsoft Defender for Identity.
+    identity_accounts: Optional[list[IdentityAccounts]] = None
     # The OdataType property
     odata_type: Optional[str] = None
+    # The sensorCandidateActivationConfiguration property
+    sensor_candidate_activation_configuration: Optional[SensorCandidateActivationConfiguration] = None
+    # Represents Microsoft Defender for Identity sensors that are ready to be activated.
+    sensor_candidates: Optional[list[SensorCandidate]] = None
     # Represents a customer's Microsoft Defender for Identity sensors.
     sensors: Optional[list[Sensor]] = None
     
@@ -38,14 +47,23 @@ class IdentityContainer(Entity, Parsable):
         """
         from ..entity import Entity
         from .health_issue import HealthIssue
+        from .identity_accounts import IdentityAccounts
         from .sensor import Sensor
+        from .sensor_candidate import SensorCandidate
+        from .sensor_candidate_activation_configuration import SensorCandidateActivationConfiguration
 
         from ..entity import Entity
         from .health_issue import HealthIssue
+        from .identity_accounts import IdentityAccounts
         from .sensor import Sensor
+        from .sensor_candidate import SensorCandidate
+        from .sensor_candidate_activation_configuration import SensorCandidateActivationConfiguration
 
         fields: dict[str, Callable[[Any], None]] = {
             "healthIssues": lambda n : setattr(self, 'health_issues', n.get_collection_of_object_values(HealthIssue)),
+            "identityAccounts": lambda n : setattr(self, 'identity_accounts', n.get_collection_of_object_values(IdentityAccounts)),
+            "sensorCandidateActivationConfiguration": lambda n : setattr(self, 'sensor_candidate_activation_configuration', n.get_object_value(SensorCandidateActivationConfiguration)),
+            "sensorCandidates": lambda n : setattr(self, 'sensor_candidates', n.get_collection_of_object_values(SensorCandidate)),
             "sensors": lambda n : setattr(self, 'sensors', n.get_collection_of_object_values(Sensor)),
         }
         super_fields = super().get_field_deserializers()
@@ -62,6 +80,9 @@ class IdentityContainer(Entity, Parsable):
             raise TypeError("writer cannot be null.")
         super().serialize(writer)
         writer.write_collection_of_object_values("healthIssues", self.health_issues)
+        writer.write_collection_of_object_values("identityAccounts", self.identity_accounts)
+        writer.write_object_value("sensorCandidateActivationConfiguration", self.sensor_candidate_activation_configuration)
+        writer.write_collection_of_object_values("sensorCandidates", self.sensor_candidates)
         writer.write_collection_of_object_values("sensors", self.sensors)
     
 

msgraph/generated/models/security/identity_provider.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class IdentityProvider(str, Enum):
+    EntraID = "entraID",
+    ActiveDirectory = "activeDirectory",
+    Okta = "okta",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/security/invoke_action_result.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 .action import Action
+    from .identity_provider import IdentityProvider
+
+@dataclass
+class InvokeActionResult(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 account ID.
+    account_id: Optional[str] = None
+    # The action property
+    action: Optional[Action] = None
+    # The unique identifier for tracking the request.
+    correlation_id: Optional[str] = None
+    # The identityProvider property
+    identity_provider: Optional[IdentityProvider] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> InvokeActionResult:
+        """
+        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: InvokeActionResult
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return InvokeActionResult()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .action import Action
+        from .identity_provider import IdentityProvider
+
+        from .action import Action
+        from .identity_provider import IdentityProvider
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "accountId": lambda n : setattr(self, 'account_id', n.get_str_value()),
+            "action": lambda n : setattr(self, 'action', n.get_enum_value(Action)),
+            "correlationId": lambda n : setattr(self, 'correlation_id', n.get_str_value()),
+            "identityProvider": lambda n : setattr(self, 'identity_provider', n.get_enum_value(IdentityProvider)),
+            "@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("accountId", self.account_id)
+        writer.write_enum_value("action", self.action)
+        writer.write_str_value("correlationId", self.correlation_id)
+        writer.write_enum_value("identityProvider", self.identity_provider)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/security/sensor_candidate.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+import datetime
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from ..entity import Entity
+
+from ..entity import Entity
+
+@dataclass
+class SensorCandidate(Entity, Parsable):
+    # The DNS name of the computer associated with the sensor.
+    computer_dns_name: Optional[str] = None
+    # The date and time when the sensor was last seen.
+    last_seen_date_time: Optional[datetime.datetime] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The version of the Defender for Identity sensor client. Supports $filter (eq).
+    sense_client_version: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SensorCandidate:
+        """
+        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: SensorCandidate
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SensorCandidate()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from ..entity import Entity
+
+        from ..entity import Entity
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "computerDnsName": lambda n : setattr(self, 'computer_dns_name', n.get_str_value()),
+            "lastSeenDateTime": lambda n : setattr(self, 'last_seen_date_time', n.get_datetime_value()),
+            "senseClientVersion": lambda n : setattr(self, 'sense_client_version', 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("computerDnsName", self.computer_dns_name)
+        writer.write_datetime_value("lastSeenDateTime", self.last_seen_date_time)
+        writer.write_str_value("senseClientVersion", self.sense_client_version)
+    
+

msgraph/generated/models/security/sensor_candidate_activation_configuration.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 ..entity import Entity
+    from .sensor_candidate_activation_mode import SensorCandidateActivationMode
+
+from ..entity import Entity
+
+@dataclass
+class SensorCandidateActivationConfiguration(Entity, Parsable):
+    # The activationMode property
+    activation_mode: Optional[SensorCandidateActivationMode] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SensorCandidateActivationConfiguration:
+        """
+        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: SensorCandidateActivationConfiguration
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SensorCandidateActivationConfiguration()
+    
+    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 .sensor_candidate_activation_mode import SensorCandidateActivationMode
+
+        from ..entity import Entity
+        from .sensor_candidate_activation_mode import SensorCandidateActivationMode
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "activationMode": lambda n : setattr(self, 'activation_mode', n.get_enum_value(SensorCandidateActivationMode)),
+        }
+        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("activationMode", self.activation_mode)
+    
+

msgraph/generated/models/security/sensor_candidate_activation_mode.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class SensorCandidateActivationMode(str, Enum):
+    Manual = "manual",
+    Automated = "automated",
+    UnknownFutureValue = "unknownFutureValue",
+

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