msgraph-sdk 1.13.0__py3-none-any.whl → 1.15.0__py3-none-any.whl

msgraph/generated/models/org_contact.py

@@ -25,7 +25,7 @@ class OrgContact(DirectoryObject, Parsable):
     department: Optional[str] = None
     # The contact's direct reports. (The users and contacts that have their manager property set to this contact.)  Read-only. Nullable. Supports $expand.
     direct_reports: Optional[List[DirectoryObject]] = None
-    # Display name for this organizational contact. Supports $filter (eq, ne, not, ge, le, in, startsWith, and eq for null values), $search, and $orderby.
+    # Display name for this organizational contact. Maximum length is 256 characters. Supports $filter (eq, ne, not, ge, le, in, startsWith, and eq for null values), $search, and $orderby.
     display_name: Optional[str] = None
     # First name for this organizational contact. Supports $filter (eq, ne, not, ge, le, in, startsWith, and eq for null values).
     given_name: Optional[str] = None

msgraph/generated/models/password_credential_configuration.py

@@ -7,6 +7,7 @@ from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
     from .app_credential_restriction_type import AppCredentialRestrictionType
+    from .app_management_restriction_state import AppManagementRestrictionState
 
 @dataclass
 class PasswordCredentialConfiguration(AdditionalDataHolder, BackedModel, Parsable):
@@ -23,6 +24,8 @@ class PasswordCredentialConfiguration(AdditionalDataHolder, BackedModel, Parsabl
     restrict_for_apps_created_after_date_time: Optional[datetime.datetime] = None
     # The type of restriction being applied. The possible values are: passwordAddition, passwordLifetime, symmetricKeyAddition, symmetricKeyLifetime, customPasswordAddition, and unknownFutureValue. Each value of restrictionType can be used only once per policy.
     restriction_type: Optional[AppCredentialRestrictionType] = None
+    # The state property
+    state: Optional[AppManagementRestrictionState] = None
     
     @staticmethod
     def create_from_discriminator_value(parse_node: ParseNode) -> PasswordCredentialConfiguration:
@@ -41,14 +44,17 @@ class PasswordCredentialConfiguration(AdditionalDataHolder, BackedModel, Parsabl
         Returns: Dict[str, Callable[[ParseNode], None]]
         """
         from .app_credential_restriction_type import AppCredentialRestrictionType
+        from .app_management_restriction_state import AppManagementRestrictionState
 
         from .app_credential_restriction_type import AppCredentialRestrictionType
+        from .app_management_restriction_state import AppManagementRestrictionState
 
         fields: Dict[str, Callable[[Any], None]] = {
             "maxLifetime": lambda n : setattr(self, 'max_lifetime', n.get_timedelta_value()),
             "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
             "restrictForAppsCreatedAfterDateTime": lambda n : setattr(self, 'restrict_for_apps_created_after_date_time', n.get_datetime_value()),
             "restrictionType": lambda n : setattr(self, 'restriction_type', n.get_enum_value(AppCredentialRestrictionType)),
+            "state": lambda n : setattr(self, 'state', n.get_enum_value(AppManagementRestrictionState)),
         }
         return fields
     
@@ -61,11 +67,13 @@ class PasswordCredentialConfiguration(AdditionalDataHolder, BackedModel, Parsabl
         if writer is None:
             raise TypeError("writer cannot be null.")
         from .app_credential_restriction_type import AppCredentialRestrictionType
+        from .app_management_restriction_state import AppManagementRestrictionState
 
         writer.write_timedelta_value("maxLifetime", self.max_lifetime)
         writer.write_str_value("@odata.type", self.odata_type)
         writer.write_datetime_value("restrictForAppsCreatedAfterDateTime", self.restrict_for_apps_created_after_date_time)
         writer.write_enum_value("restrictionType", self.restriction_type)
+        writer.write_enum_value("state", self.state)
         writer.write_additional_data_value(self.additional_data)
     
 

msgraph/generated/models/recycle_bin.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .base_item import BaseItem
+    from .recycle_bin_item import RecycleBinItem
+    from .recycle_bin_settings import RecycleBinSettings
+
+from .base_item import BaseItem
+
+@dataclass
+class RecycleBin(BaseItem, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.recycleBin"
+    # List of the recycleBinItems deleted by a user.
+    items: Optional[List[RecycleBinItem]] = None
+    # The settings property
+    settings: Optional[RecycleBinSettings] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> RecycleBin:
+        """
+        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: RecycleBin
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return RecycleBin()
+    
+    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_item import BaseItem
+        from .recycle_bin_item import RecycleBinItem
+        from .recycle_bin_settings import RecycleBinSettings
+
+        from .base_item import BaseItem
+        from .recycle_bin_item import RecycleBinItem
+        from .recycle_bin_settings import RecycleBinSettings
+
+        fields: Dict[str, Callable[[Any], None]] = {
+            "items": lambda n : setattr(self, 'items', n.get_collection_of_object_values(RecycleBinItem)),
+            "settings": lambda n : setattr(self, 'settings', n.get_object_value(RecycleBinSettings)),
+        }
+        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)
+        from .base_item import BaseItem
+        from .recycle_bin_item import RecycleBinItem
+        from .recycle_bin_settings import RecycleBinSettings
+
+        writer.write_collection_of_object_values("items", self.items)
+        writer.write_object_value("settings", self.settings)
+    
+

msgraph/generated/models/recycle_bin_item.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+import datetime
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .base_item import BaseItem
+
+from .base_item import BaseItem
+
+@dataclass
+class RecycleBinItem(BaseItem, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.recycleBinItem"
+    # Date and time when the item was deleted. The timestamp type represents date and time information using ISO 8601 format and is always in UTC. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z.
+    deleted_date_time: Optional[datetime.datetime] = None
+    # Relative URL of the list or folder that originally contained the item.
+    deleted_from_location: Optional[str] = None
+    # Size of the item in bytes.
+    size: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> RecycleBinItem:
+        """
+        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: RecycleBinItem
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return RecycleBinItem()
+    
+    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_item import BaseItem
+
+        from .base_item import BaseItem
+
+        fields: Dict[str, Callable[[Any], None]] = {
+            "deletedDateTime": lambda n : setattr(self, 'deleted_date_time', n.get_datetime_value()),
+            "deletedFromLocation": lambda n : setattr(self, 'deleted_from_location', n.get_str_value()),
+            "size": lambda n : setattr(self, 'size', 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)
+        from .base_item import BaseItem
+
+        writer.write_datetime_value("deletedDateTime", self.deleted_date_time)
+        writer.write_str_value("deletedFromLocation", self.deleted_from_location)
+        writer.write_int_value("size", self.size)
+    
+

msgraph/generated/models/recycle_bin_item_collection_response.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+    from .recycle_bin_item import RecycleBinItem
+
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+
+@dataclass
+class RecycleBinItemCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[List[RecycleBinItem]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> RecycleBinItemCollectionResponse:
+        """
+        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: RecycleBinItemCollectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return RecycleBinItemCollectionResponse()
+    
+    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 .recycle_bin_item import RecycleBinItem
+
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .recycle_bin_item import RecycleBinItem
+
+        fields: Dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(RecycleBinItem)),
+        }
+        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)
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .recycle_bin_item import RecycleBinItem
+
+        writer.write_collection_of_object_values("value", self.value)
+    
+

msgraph/generated/models/recycle_bin_settings.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+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, Callable, Dict, List, Optional, TYPE_CHECKING, Union
+
+@dataclass
+class RecycleBinSettings(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
+    # Recycle bin retention period override in days for deleted content. The default value is 93; the value range is 7 to 180. The setting applies to newly deleted content only. Setting this property to null reverts to its default value. Read-write.
+    retention_period_override_days: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> RecycleBinSettings:
+        """
+        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: RecycleBinSettings
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return RecycleBinSettings()
+    
+    def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: Dict[str, Callable[[ParseNode], None]]
+        """
+        fields: Dict[str, Callable[[Any], None]] = {
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "retentionPeriodOverrideDays": lambda n : setattr(self, 'retention_period_override_days', n.get_int_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_int_value("retentionPeriodOverrideDays", self.retention_period_override_days)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/security/data_set.py

@@ -17,6 +17,8 @@ class DataSet(Entity, Parsable):
     created_by: Optional[IdentitySet] = None
     # The createdDateTime property
     created_date_time: Optional[datetime.datetime] = None
+    # The description property
+    description: Optional[str] = None
     # The displayName property
     display_name: Optional[str] = None
     # The OdataType property
@@ -58,6 +60,7 @@ class DataSet(Entity, Parsable):
         fields: Dict[str, Callable[[Any], None]] = {
             "createdBy": lambda n : setattr(self, 'created_by', n.get_object_value(IdentitySet)),
             "createdDateTime": lambda n : setattr(self, 'created_date_time', n.get_datetime_value()),
+            "description": lambda n : setattr(self, 'description', n.get_str_value()),
             "displayName": lambda n : setattr(self, 'display_name', n.get_str_value()),
         }
         super_fields = super().get_field_deserializers()
@@ -79,6 +82,7 @@ class DataSet(Entity, Parsable):
 
         writer.write_object_value("createdBy", self.created_by)
         writer.write_datetime_value("createdDateTime", self.created_date_time)
+        writer.write_str_value("description", self.description)
         writer.write_str_value("displayName", self.display_name)
     
 

msgraph/generated/models/security/deployment_access_key_type.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+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, Callable, Dict, List, Optional, TYPE_CHECKING, Union
+
+@dataclass
+class DeploymentAccessKeyType(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 deployment access key.
+    deployment_access_key: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> DeploymentAccessKeyType:
+        """
+        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: DeploymentAccessKeyType
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return DeploymentAccessKeyType()
+    
+    def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: Dict[str, Callable[[ParseNode], None]]
+        """
+        fields: Dict[str, Callable[[Any], None]] = {
+            "deploymentAccessKey": lambda n : setattr(self, 'deployment_access_key', n.get_str_value()),
+            "@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("deploymentAccessKey", self.deployment_access_key)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/security/deployment_status.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+class DeploymentStatus(str, Enum):
+    UpToDate = "upToDate",
+    Outdated = "outdated",
+    Updating = "updating",
+    UpdateFailed = "updateFailed",
+    NotConfigured = "notConfigured",
+    Unreachable = "unreachable",
+    Disconnected = "disconnected",
+    StartFailure = "startFailure",
+    Syncing = "syncing",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/security/evidence_remediation_status.py

@@ -7,4 +7,10 @@ class EvidenceRemediationStatus(str, Enum):
     Blocked = "blocked",
     NotFound = "notFound",
     UnknownFutureValue = "unknownFutureValue",
+    Active = "active",
+    PendingApproval = "pendingApproval",
+    Declined = "declined",
+    Unremediated = "unremediated",
+    Running = "running",
+    PartiallyRemediated = "partiallyRemediated",
 

msgraph/generated/models/security/identity_container.py

@@ -6,6 +6,7 @@ from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union
 if TYPE_CHECKING:
     from ..entity import Entity
     from .health_issue import HealthIssue
+    from .sensor import Sensor
 
 from ..entity import Entity
 
@@ -15,6 +16,8 @@ class IdentityContainer(Entity, Parsable):
     health_issues: Optional[List[HealthIssue]] = None
     # The OdataType property
     odata_type: Optional[str] = None
+    # Represents a customer's Microsoft Defender for Identity sensors.
+    sensors: Optional[List[Sensor]] = None
     
     @staticmethod
     def create_from_discriminator_value(parse_node: ParseNode) -> IdentityContainer:
@@ -34,12 +37,15 @@ class IdentityContainer(Entity, Parsable):
         """
         from ..entity import Entity
         from .health_issue import HealthIssue
+        from .sensor import Sensor
 
         from ..entity import Entity
         from .health_issue import HealthIssue
+        from .sensor import Sensor
 
         fields: Dict[str, Callable[[Any], None]] = {
             "healthIssues": lambda n : setattr(self, 'health_issues', n.get_collection_of_object_values(HealthIssue)),
+            "sensors": lambda n : setattr(self, 'sensors', n.get_collection_of_object_values(Sensor)),
         }
         super_fields = super().get_field_deserializers()
         fields.update(super_fields)
@@ -56,7 +62,9 @@ class IdentityContainer(Entity, Parsable):
         super().serialize(writer)
         from ..entity import Entity
         from .health_issue import HealthIssue
+        from .sensor import Sensor
 
         writer.write_collection_of_object_values("healthIssues", self.health_issues)
+        writer.write_collection_of_object_values("sensors", self.sensors)
     
 

msgraph/generated/models/security/network_adapter.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from ..entity import Entity
+
+from ..entity import Entity
+
+@dataclass
+class NetworkAdapter(Entity, Parsable):
+    # Indicates whether the network adapter is selected for capturing and analyzing network traffic.
+    is_enabled: Optional[bool] = None
+    # The name of the network adapter.
+    name: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> NetworkAdapter:
+        """
+        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: NetworkAdapter
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return NetworkAdapter()
+    
+    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]] = {
+            "isEnabled": lambda n : setattr(self, 'is_enabled', n.get_bool_value()),
+            "name": lambda n : setattr(self, 'name', 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)
+        from ..entity import Entity
+
+        writer.write_bool_value("isEnabled", self.is_enabled)
+        writer.write_str_value("name", self.name)
+    
+

msgraph/generated/models/security/sensor.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+import datetime
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from ..entity import Entity
+    from .deployment_status import DeploymentStatus
+    from .health_issue import HealthIssue
+    from .sensor_health_status import SensorHealthStatus
+    from .sensor_settings import SensorSettings
+    from .sensor_type import SensorType
+
+from ..entity import Entity
+
+@dataclass
+class Sensor(Entity, Parsable):
+    # The date and time when the sensor was generated. The Timestamp represents date and time information using ISO 8601 format and is always in UTC. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z.
+    created_date_time: Optional[datetime.datetime] = None
+    # The deploymentStatus property
+    deployment_status: Optional[DeploymentStatus] = None
+    # The display name of the sensor.
+    display_name: Optional[str] = None
+    # The fully qualified domain name of the sensor.
+    domain_name: Optional[str] = None
+    # Represents potential issues within a customer's Microsoft Defender for Identity configuration that Microsoft Defender for Identity identified related to the sensor.
+    health_issues: Optional[List[HealthIssue]] = None
+    # The healthStatus property
+    health_status: Optional[SensorHealthStatus] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # This field displays the count of health issues related to this sensor.
+    open_health_issues_count: Optional[int] = None
+    # The sensorType property
+    sensor_type: Optional[SensorType] = None
+    # The settings property
+    settings: Optional[SensorSettings] = None
+    # The version of the sensor.
+    version: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> Sensor:
+        """
+        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: Sensor
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return Sensor()
+    
+    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 .deployment_status import DeploymentStatus
+        from .health_issue import HealthIssue
+        from .sensor_health_status import SensorHealthStatus
+        from .sensor_settings import SensorSettings
+        from .sensor_type import SensorType
+
+        from ..entity import Entity
+        from .deployment_status import DeploymentStatus
+        from .health_issue import HealthIssue
+        from .sensor_health_status import SensorHealthStatus
+        from .sensor_settings import SensorSettings
+        from .sensor_type import SensorType
+
+        fields: Dict[str, Callable[[Any], None]] = {
+            "createdDateTime": lambda n : setattr(self, 'created_date_time', n.get_datetime_value()),
+            "deploymentStatus": lambda n : setattr(self, 'deployment_status', n.get_enum_value(DeploymentStatus)),
+            "displayName": lambda n : setattr(self, 'display_name', n.get_str_value()),
+            "domainName": lambda n : setattr(self, 'domain_name', n.get_str_value()),
+            "healthIssues": lambda n : setattr(self, 'health_issues', n.get_collection_of_object_values(HealthIssue)),
+            "healthStatus": lambda n : setattr(self, 'health_status', n.get_enum_value(SensorHealthStatus)),
+            "openHealthIssuesCount": lambda n : setattr(self, 'open_health_issues_count', n.get_int_value()),
+            "sensorType": lambda n : setattr(self, 'sensor_type', n.get_enum_value(SensorType)),
+            "settings": lambda n : setattr(self, 'settings', n.get_object_value(SensorSettings)),
+            "version": lambda n : setattr(self, '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)
+        from ..entity import Entity
+        from .deployment_status import DeploymentStatus
+        from .health_issue import HealthIssue
+        from .sensor_health_status import SensorHealthStatus
+        from .sensor_settings import SensorSettings
+        from .sensor_type import SensorType
+
+        writer.write_datetime_value("createdDateTime", self.created_date_time)
+        writer.write_enum_value("deploymentStatus", self.deployment_status)
+        writer.write_str_value("displayName", self.display_name)
+        writer.write_str_value("domainName", self.domain_name)
+        writer.write_collection_of_object_values("healthIssues", self.health_issues)
+        writer.write_enum_value("healthStatus", self.health_status)
+        writer.write_int_value("openHealthIssuesCount", self.open_health_issues_count)
+        writer.write_enum_value("sensorType", self.sensor_type)
+        writer.write_object_value("settings", self.settings)
+        writer.write_str_value("version", self.version)
+    
+