msgraph-sdk 1.36.0__py3-none-any.whl → 1.38.0__py3-none-any.whl

msgraph/generated/models/security/windows365_customer_lockbox_audit_record.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 .audit_data import AuditData
+
+from .audit_data import AuditData
+
+@dataclass
+class Windows365CustomerLockboxAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.windows365CustomerLockboxAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> Windows365CustomerLockboxAuditRecord:
+        """
+        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: Windows365CustomerLockboxAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return Windows365CustomerLockboxAuditRecord()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .audit_data import AuditData
+
+        from .audit_data import AuditData
+
+        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/security/workplace_analytics_audit_record.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 .audit_data import AuditData
+
+from .audit_data import AuditData
+
+@dataclass
+class WorkplaceAnalyticsAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.workplaceAnalyticsAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> WorkplaceAnalyticsAuditRecord:
+        """
+        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: WorkplaceAnalyticsAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return WorkplaceAnalyticsAuditRecord()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .audit_data import AuditData
+
+        from .audit_data import AuditData
+
+        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/security/yammer_audit_record.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 .audit_data import AuditData
+
+from .audit_data import AuditData
+
+@dataclass
+class YammerAuditRecord(AuditData, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.yammerAuditRecord"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> YammerAuditRecord:
+        """
+        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: YammerAuditRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return YammerAuditRecord()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .audit_data import AuditData
+
+        from .audit_data import AuditData
+
+        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/sensitivity_label.py

@@ -0,0 +1,111 @@
+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 .label_action_source import LabelActionSource
+    from .usage_rights_included import UsageRightsIncluded
+
+from .entity import Entity
+
+@dataclass
+class SensitivityLabel(Entity, Parsable):
+    # The actionSource property
+    action_source: Optional[LabelActionSource] = None
+    # The autoTooltip property
+    auto_tooltip: Optional[str] = None
+    # The description property
+    description: Optional[str] = None
+    # The displayName property
+    display_name: Optional[str] = None
+    # The isDefault property
+    is_default: Optional[bool] = None
+    # The isEndpointProtectionEnabled property
+    is_endpoint_protection_enabled: Optional[bool] = None
+    # The isScopedToUser property
+    is_scoped_to_user: Optional[bool] = None
+    # The locale property
+    locale: Optional[str] = None
+    # The name property
+    name: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The priority property
+    priority: Optional[int] = None
+    # The rights property
+    rights: Optional[UsageRightsIncluded] = None
+    # The sublabels property
+    sublabels: Optional[list[SensitivityLabel]] = None
+    # The toolTip property
+    tool_tip: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SensitivityLabel:
+        """
+        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: SensitivityLabel
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SensitivityLabel()
+    
+    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 .label_action_source import LabelActionSource
+        from .usage_rights_included import UsageRightsIncluded
+
+        from .entity import Entity
+        from .label_action_source import LabelActionSource
+        from .usage_rights_included import UsageRightsIncluded
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "actionSource": lambda n : setattr(self, 'action_source', n.get_enum_value(LabelActionSource)),
+            "autoTooltip": lambda n : setattr(self, 'auto_tooltip', n.get_str_value()),
+            "description": lambda n : setattr(self, 'description', n.get_str_value()),
+            "displayName": lambda n : setattr(self, 'display_name', n.get_str_value()),
+            "isDefault": lambda n : setattr(self, 'is_default', n.get_bool_value()),
+            "isEndpointProtectionEnabled": lambda n : setattr(self, 'is_endpoint_protection_enabled', n.get_bool_value()),
+            "isScopedToUser": lambda n : setattr(self, 'is_scoped_to_user', n.get_bool_value()),
+            "locale": lambda n : setattr(self, 'locale', n.get_str_value()),
+            "name": lambda n : setattr(self, 'name', n.get_str_value()),
+            "priority": lambda n : setattr(self, 'priority', n.get_int_value()),
+            "rights": lambda n : setattr(self, 'rights', n.get_object_value(UsageRightsIncluded)),
+            "sublabels": lambda n : setattr(self, 'sublabels', n.get_collection_of_object_values(SensitivityLabel)),
+            "toolTip": lambda n : setattr(self, 'tool_tip', 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_enum_value("actionSource", self.action_source)
+        writer.write_str_value("autoTooltip", self.auto_tooltip)
+        writer.write_str_value("description", self.description)
+        writer.write_str_value("displayName", self.display_name)
+        writer.write_bool_value("isDefault", self.is_default)
+        writer.write_bool_value("isEndpointProtectionEnabled", self.is_endpoint_protection_enabled)
+        writer.write_bool_value("isScopedToUser", self.is_scoped_to_user)
+        writer.write_str_value("locale", self.locale)
+        writer.write_str_value("name", self.name)
+        writer.write_int_value("priority", self.priority)
+        writer.write_object_value("rights", self.rights)
+        writer.write_collection_of_object_values("sublabels", self.sublabels)
+        writer.write_str_value("toolTip", self.tool_tip)
+    
+

msgraph/generated/models/sensitivity_label_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 .sensitivity_label import SensitivityLabel
+
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+
+@dataclass
+class SensitivityLabelCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[list[SensitivityLabel]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SensitivityLabelCollectionResponse:
+        """
+        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: SensitivityLabelCollectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SensitivityLabelCollectionResponse()
+    
+    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 .sensitivity_label import SensitivityLabel
+
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .sensitivity_label import SensitivityLabel
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(SensitivityLabel)),
+        }
+        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/tenant_data_security_and_governance.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 .data_security_and_governance import DataSecurityAndGovernance
+    from .tenant_protection_scope_container import TenantProtectionScopeContainer
+
+from .data_security_and_governance import DataSecurityAndGovernance
+
+@dataclass
+class TenantDataSecurityAndGovernance(DataSecurityAndGovernance, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.tenantDataSecurityAndGovernance"
+    # The protectionScopes property
+    protection_scopes: Optional[TenantProtectionScopeContainer] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> TenantDataSecurityAndGovernance:
+        """
+        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: TenantDataSecurityAndGovernance
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return TenantDataSecurityAndGovernance()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .data_security_and_governance import DataSecurityAndGovernance
+        from .tenant_protection_scope_container import TenantProtectionScopeContainer
+
+        from .data_security_and_governance import DataSecurityAndGovernance
+        from .tenant_protection_scope_container import TenantProtectionScopeContainer
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "protectionScopes": lambda n : setattr(self, 'protection_scopes', n.get_object_value(TenantProtectionScopeContainer)),
+        }
+        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("protectionScopes", self.protection_scopes)
+    
+

msgraph/generated/models/tenant_protection_scope_container.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 .entity import Entity
+
+from .entity import Entity
+
+@dataclass
+class TenantProtectionScopeContainer(Entity, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> TenantProtectionScopeContainer:
+        """
+        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: TenantProtectionScopeContainer
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return TenantProtectionScopeContainer()
+    
+    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]] = {
+        }
+        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/tenant_scope.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 .scope_base import ScopeBase
+
+from .scope_base import ScopeBase
+
+@dataclass
+class TenantScope(ScopeBase, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.tenantScope"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> TenantScope:
+        """
+        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: TenantScope
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return TenantScope()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .scope_base import ScopeBase
+
+        from .scope_base import ScopeBase
+
+        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/text_content.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 .content_base import ContentBase
+
+from .content_base import ContentBase
+
+@dataclass
+class TextContent(ContentBase, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.textContent"
+    # The text content data. Inherits properties from contentBase.
+    data: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> TextContent:
+        """
+        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: TextContent
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return TextContent()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .content_base import ContentBase
+
+        from .content_base import ContentBase
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "data": lambda n : setattr(self, 'data', 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("data", self.data)
+    
+

msgraph/generated/models/upload_session.py

@@ -13,7 +13,7 @@ class UploadSession(AdditionalDataHolder, BackedModel, Parsable):
 
     # 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 date and time in UTC that the upload session will expire. The complete file must be uploaded before this expiration time is reached.
+    # The date and time in UTC that the upload session expires. The complete file must be uploaded before this expiration time is reached. Each fragment uploaded during the session extends the expiration time.
     expiration_date_time: Optional[datetime.datetime] = None
     # A collection of byte ranges that the server is missing for the file. These ranges are zero indexed and of the format 'start-end' (for example '0-26' to indicate the first 27 bytes of the file). When uploading files as Outlook attachments, instead of a collection of ranges, this property always indicates a single value '{start}', the location in the file where the next upload should begin.
     next_expected_ranges: Optional[list[str]] = None

msgraph/generated/models/usage_rights.py

@@ -0,0 +1,25 @@
+from enum import Enum
+
+class UsageRights(str, Enum):
+    Unknown = "unknown",
+    DocEdit = "docEdit",
+    Edit = "edit",
+    Comment = "comment",
+    Export = "export",
+    Forward = "forward",
+    Owner = "owner",
+    Print = "print",
+    Reply = "reply",
+    ReplyAll = "replyAll",
+    View = "view",
+    Extract = "extract",
+    ViewRightsData = "viewRightsData",
+    EditRightsData = "editRightsData",
+    ObjModel = "objModel",
+    AccessDenied = "accessDenied",
+    UserDefinedProtectionTypeNotSupportedException = "userDefinedProtectionTypeNotSupportedException",
+    EncryptedProtectionTypeNotSupportedException = "encryptedProtectionTypeNotSupportedException",
+    PurviewClaimsChallengeNotSupportedException = "purviewClaimsChallengeNotSupportedException",
+    Exception = "exception",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/usage_rights_included.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 .usage_rights import UsageRights
+
+from .entity import Entity
+
+@dataclass
+class UsageRightsIncluded(Entity, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The email of owner label rights.
+    owner_email: Optional[str] = None
+    # The email of user with label user rights.
+    user_email: Optional[str] = None
+    # The value property
+    value: Optional[UsageRights] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UsageRightsIncluded:
+        """
+        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: UsageRightsIncluded
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UsageRightsIncluded()
+    
+    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 .usage_rights import UsageRights
+
+        from .entity import Entity
+        from .usage_rights import UsageRights
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "ownerEmail": lambda n : setattr(self, 'owner_email', n.get_str_value()),
+            "userEmail": lambda n : setattr(self, 'user_email', n.get_str_value()),
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_enum_values(UsageRights)),
+        }
+        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("ownerEmail", self.owner_email)
+        writer.write_str_value("userEmail", self.user_email)
+        writer.write_enum_value("value", self.value)
+    
+