msgraph-sdk 1.35.0__py3-none-any.whl → 1.37.0__py3-none-any.whl

msgraph/generated/models/content_activity.py

@@ -0,0 +1,68 @@
+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 .process_content_request import ProcessContentRequest
+
+from .entity import Entity
+
+@dataclass
+class ContentActivity(Entity, Parsable):
+    # The contentMetadata property
+    content_metadata: Optional[ProcessContentRequest] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The scope identified from computed protection scopes.
+    scope_identifier: Optional[str] = None
+    # ID of the user.
+    user_id: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ContentActivity:
+        """
+        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: ContentActivity
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ContentActivity()
+    
+    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 .process_content_request import ProcessContentRequest
+
+        from .entity import Entity
+        from .process_content_request import ProcessContentRequest
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "contentMetadata": lambda n : setattr(self, 'content_metadata', n.get_object_value(ProcessContentRequest)),
+            "scopeIdentifier": lambda n : setattr(self, 'scope_identifier', n.get_str_value()),
+            "userId": lambda n : setattr(self, 'user_id', n.get_str_value()),
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+        writer.write_object_value("contentMetadata", self.content_metadata)
+        writer.write_str_value("scopeIdentifier", self.scope_identifier)
+        writer.write_str_value("userId", self.user_id)
+    
+

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

@@ -0,0 +1,73 @@
+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 .binary_content import BinaryContent
+    from .text_content import TextContent
+
+@dataclass
+class ContentBase(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) -> ContentBase:
+        """
+        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: ContentBase
+        """
+        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.binaryContent".casefold():
+            from .binary_content import BinaryContent
+
+            return BinaryContent()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.textContent".casefold():
+            from .text_content import TextContent
+
+            return TextContent()
+        return ContentBase()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .binary_content import BinaryContent
+        from .text_content import TextContent
+
+        from .binary_content import BinaryContent
+        from .text_content import TextContent
+
+        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/content_processing_error_type.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class ContentProcessingErrorType(str, Enum):
+    Transient = "transient",
+    Permanent = "permanent",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/custom_metadata_dictionary.py

@@ -0,0 +1,53 @@
+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 .dictionary import Dictionary
+
+from .dictionary import Dictionary
+
+@dataclass
+class CustomMetadataDictionary(Dictionary, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> CustomMetadataDictionary:
+        """
+        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: CustomMetadataDictionary
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return CustomMetadataDictionary()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .dictionary import Dictionary
+
+        from .dictionary import Dictionary
+
+        fields: dict[str, Callable[[Any], None]] = {
+        }
+        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)
+    
+

msgraph/generated/models/data_security_and_governance.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 .entity import Entity
+    from .tenant_data_security_and_governance import TenantDataSecurityAndGovernance
+    from .user_data_security_and_governance import UserDataSecurityAndGovernance
+
+from .entity import Entity
+
+@dataclass
+class DataSecurityAndGovernance(Entity, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> DataSecurityAndGovernance:
+        """
+        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: DataSecurityAndGovernance
+        """
+        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.tenantDataSecurityAndGovernance".casefold():
+            from .tenant_data_security_and_governance import TenantDataSecurityAndGovernance
+
+            return TenantDataSecurityAndGovernance()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.userDataSecurityAndGovernance".casefold():
+            from .user_data_security_and_governance import UserDataSecurityAndGovernance
+
+            return UserDataSecurityAndGovernance()
+        return DataSecurityAndGovernance()
+    
+    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 .tenant_data_security_and_governance import TenantDataSecurityAndGovernance
+        from .user_data_security_and_governance import UserDataSecurityAndGovernance
+
+        from .entity import Entity
+        from .tenant_data_security_and_governance import TenantDataSecurityAndGovernance
+        from .user_data_security_and_governance import UserDataSecurityAndGovernance
+
+        fields: dict[str, Callable[[Any], None]] = {
+        }
+        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)
+    
+

msgraph/generated/models/device.py

@@ -46,7 +46,7 @@ class Device(DirectoryObject, Parsable):
     is_compliant: Optional[bool] = None
     # true if the device is managed by a Mobile Device Management (MDM) app; otherwise, false. This can only be updated by Intune for any device OS type or by an approved MDM app for Windows OS devices. Supports $filter (eq, ne, not).
     is_managed: Optional[bool] = None
-    # The isManagementRestricted property
+    # Indicates whether the device is a member of a restricted management administrative unit. If not set, the default value is null and the default behavior is false. Read-only.  To manage a device that's a member of a restricted management administrative unit, the administrator or calling app must be assigned a Microsoft Entra role at the scope of the restricted management administrative unit. Returned only on $select.
     is_management_restricted: Optional[bool] = None
     # true if the device is rooted or jail-broken. This property can only be updated by Intune.
     is_rooted: Optional[bool] = None

msgraph/generated/models/device_metadata.py

@@ -0,0 +1,69 @@
+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 .operating_system_specifications import OperatingSystemSpecifications
+
+@dataclass
+class DeviceMetadata(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)
+    # Optional. The general type of the device (for example, 'Managed', 'Unmanaged').
+    device_type: Optional[str] = None
+    # The Internet Protocol (IP) address of the device.
+    ip_address: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # Details about the operating system platform and version.
+    operating_system_specifications: Optional[OperatingSystemSpecifications] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> DeviceMetadata:
+        """
+        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: DeviceMetadata
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return DeviceMetadata()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .operating_system_specifications import OperatingSystemSpecifications
+
+        from .operating_system_specifications import OperatingSystemSpecifications
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "deviceType": lambda n : setattr(self, 'device_type', n.get_str_value()),
+            "ipAddress": lambda n : setattr(self, 'ip_address', n.get_str_value()),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "operatingSystemSpecifications": lambda n : setattr(self, 'operating_system_specifications', n.get_object_value(OperatingSystemSpecifications)),
+        }
+        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("deviceType", self.device_type)
+        writer.write_str_value("ipAddress", self.ip_address)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_object_value("operatingSystemSpecifications", self.operating_system_specifications)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/dictionary.py

@@ -6,6 +6,7 @@ from kiota_abstractions.store import BackedModel, BackingStore, BackingStoreFact
 from typing import Any, Optional, TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
+    from .custom_metadata_dictionary import CustomMetadataDictionary
     from .file_storage_container_custom_property_dictionary import FileStorageContainerCustomPropertyDictionary
     from .result_template_dictionary import ResultTemplateDictionary
 
@@ -33,6 +34,10 @@ class Dictionary(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.customMetadataDictionary".casefold():
+            from .custom_metadata_dictionary import CustomMetadataDictionary
+
+            return CustomMetadataDictionary()
         if mapping_value and mapping_value.casefold() == "#microsoft.graph.fileStorageContainerCustomPropertyDictionary".casefold():
             from .file_storage_container_custom_property_dictionary import FileStorageContainerCustomPropertyDictionary
 
@@ -48,9 +53,11 @@ class Dictionary(AdditionalDataHolder, BackedModel, Parsable):
         The deserialization information for the current model
         Returns: dict[str, Callable[[ParseNode], None]]
         """
+        from .custom_metadata_dictionary import CustomMetadataDictionary
         from .file_storage_container_custom_property_dictionary import FileStorageContainerCustomPropertyDictionary
         from .result_template_dictionary import ResultTemplateDictionary
 
+        from .custom_metadata_dictionary import CustomMetadataDictionary
         from .file_storage_container_custom_property_dictionary import FileStorageContainerCustomPropertyDictionary
         from .result_template_dictionary import ResultTemplateDictionary
 

msgraph/generated/models/directory.py

@@ -36,7 +36,7 @@ class Directory(Entity, Parsable):
     odata_type: Optional[str] = None
     # A container for on-premises directory synchronization functionalities that are available for the organization.
     on_premises_synchronization: Optional[list[OnPremisesDirectorySynchronization]] = None
-    # The publicKeyInfrastructure property
+    # The collection of public key infrastructure instances for the certificate-based authentication feature for users in a Microsoft Entra tenant.
     public_key_infrastructure: Optional[PublicKeyInfrastructureRoot] = None
     # List of commercial subscriptions that an organization acquired.
     subscriptions: Optional[list[CompanySubscription]] = None

msgraph/generated/models/dlp_action.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+class DlpAction(str, Enum):
+    NotifyUser = "notifyUser",
+    BlockAccess = "blockAccess",
+    DeviceRestriction = "deviceRestriction",
+    BrowserRestriction = "browserRestriction",
+    UnknownFutureValue = "unknownFutureValue",
+    RestrictAccess = "restrictAccess",
+    GenerateAlert = "generateAlert",
+    GenerateIncidentReportAction = "generateIncidentReportAction",
+    SPBlockAnonymousAccess = "sPBlockAnonymousAccess",
+    SPRuntimeAccessControl = "sPRuntimeAccessControl",
+    SPSharingNotifyUser = "sPSharingNotifyUser",
+    SPSharingGenerateIncidentReport = "sPSharingGenerateIncidentReport",
+

msgraph/generated/models/dlp_action_info.py

@@ -0,0 +1,80 @@
+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 .dlp_action import DlpAction
+    from .restrict_access_action import RestrictAccessAction
+    from .restrict_access_action_base import RestrictAccessActionBase
+
+@dataclass
+class DlpActionInfo(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 type of DLP action. Possible value is restrictAccessAction.
+    action: Optional[DlpAction] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> DlpActionInfo:
+        """
+        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: DlpActionInfo
+        """
+        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.restrictAccessAction".casefold():
+            from .restrict_access_action import RestrictAccessAction
+
+            return RestrictAccessAction()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.restrictAccessActionBase".casefold():
+            from .restrict_access_action_base import RestrictAccessActionBase
+
+            return RestrictAccessActionBase()
+        return DlpActionInfo()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .dlp_action import DlpAction
+        from .restrict_access_action import RestrictAccessAction
+        from .restrict_access_action_base import RestrictAccessActionBase
+
+        from .dlp_action import DlpAction
+        from .restrict_access_action import RestrictAccessAction
+        from .restrict_access_action_base import RestrictAccessActionBase
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "action": lambda n : setattr(self, 'action', n.get_enum_value(DlpAction)),
+            "@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_enum_value("action", self.action)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/emergency_call_event.py

@@ -0,0 +1,68 @@
+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 .call_event import CallEvent
+    from .emergency_caller_info import EmergencyCallerInfo
+
+from .call_event import CallEvent
+
+@dataclass
+class EmergencyCallEvent(CallEvent, Parsable):
+    # The callerInfo property
+    caller_info: Optional[EmergencyCallerInfo] = None
+    # The emergencyNumberDialed property
+    emergency_number_dialed: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The policyName property
+    policy_name: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> EmergencyCallEvent:
+        """
+        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: EmergencyCallEvent
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return EmergencyCallEvent()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .call_event import CallEvent
+        from .emergency_caller_info import EmergencyCallerInfo
+
+        from .call_event import CallEvent
+        from .emergency_caller_info import EmergencyCallerInfo
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "callerInfo": lambda n : setattr(self, 'caller_info', n.get_object_value(EmergencyCallerInfo)),
+            "emergencyNumberDialed": lambda n : setattr(self, 'emergency_number_dialed', n.get_str_value()),
+            "policyName": lambda n : setattr(self, 'policy_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)
+        writer.write_object_value("callerInfo", self.caller_info)
+        writer.write_str_value("emergencyNumberDialed", self.emergency_number_dialed)
+        writer.write_str_value("policyName", self.policy_name)
+    
+