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

msgraph/generated/models/operating_system_specifications.py

@@ -0,0 +1,58 @@
+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
+
+@dataclass
+class OperatingSystemSpecifications(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
+    # The platform of the operating system (for example, 'Windows').
+    operating_system_platform: Optional[str] = None
+    # The version string of the operating system.
+    operating_system_version: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> OperatingSystemSpecifications:
+        """
+        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: OperatingSystemSpecifications
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return OperatingSystemSpecifications()
+    
+    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()),
+            "operatingSystemPlatform": lambda n : setattr(self, 'operating_system_platform', n.get_str_value()),
+            "operatingSystemVersion": lambda n : setattr(self, 'operating_system_version', 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_str_value("operatingSystemPlatform", self.operating_system_platform)
+        writer.write_str_value("operatingSystemVersion", self.operating_system_version)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/partners/billing/billing_reconciliation.py

@@ -7,6 +7,7 @@ from typing import Any, Optional, TYPE_CHECKING, Union
 if TYPE_CHECKING:
     from ...entity import Entity
     from .billed_reconciliation import BilledReconciliation
+    from .unbilled_reconciliation import UnbilledReconciliation
 
 from ...entity import Entity
 
@@ -16,6 +17,8 @@ class BillingReconciliation(Entity, Parsable):
     billed: Optional[BilledReconciliation] = None
     # The OdataType property
     odata_type: Optional[str] = None
+    # The unbilled property
+    unbilled: Optional[UnbilledReconciliation] = None
     
     @staticmethod
     def create_from_discriminator_value(parse_node: ParseNode) -> BillingReconciliation:
@@ -35,12 +38,15 @@ class BillingReconciliation(Entity, Parsable):
         """
         from ...entity import Entity
         from .billed_reconciliation import BilledReconciliation
+        from .unbilled_reconciliation import UnbilledReconciliation
 
         from ...entity import Entity
         from .billed_reconciliation import BilledReconciliation
+        from .unbilled_reconciliation import UnbilledReconciliation
 
         fields: dict[str, Callable[[Any], None]] = {
             "billed": lambda n : setattr(self, 'billed', n.get_object_value(BilledReconciliation)),
+            "unbilled": lambda n : setattr(self, 'unbilled', n.get_object_value(UnbilledReconciliation)),
         }
         super_fields = super().get_field_deserializers()
         fields.update(super_fields)
@@ -56,5 +62,6 @@ class BillingReconciliation(Entity, Parsable):
             raise TypeError("writer cannot be null.")
         super().serialize(writer)
         writer.write_object_value("billed", self.billed)
+        writer.write_object_value("unbilled", self.unbilled)
     
 

msgraph/generated/models/partners/billing/unbilled_reconciliation.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 UnbilledReconciliation(Entity, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UnbilledReconciliation:
+        """
+        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: UnbilledReconciliation
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UnbilledReconciliation()
+    
+    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/policy_binding.py

@@ -0,0 +1,65 @@
+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 .scope_base import ScopeBase
+
+@dataclass
+class PolicyBinding(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)
+    # Specifies the users or groups to be explicitly excluded from this policy scope. Can be null or empty.
+    exclusions: Optional[list[ScopeBase]] = None
+    # Specifies the users or groups to be included in this policy scope. Often set to tenantScope for 'All users'.
+    inclusions: Optional[list[ScopeBase]] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PolicyBinding:
+        """
+        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: PolicyBinding
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PolicyBinding()
+    
+    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]] = {
+            "exclusions": lambda n : setattr(self, 'exclusions', n.get_collection_of_object_values(ScopeBase)),
+            "inclusions": lambda n : setattr(self, 'inclusions', n.get_collection_of_object_values(ScopeBase)),
+            "@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_collection_of_object_values("exclusions", self.exclusions)
+        writer.write_collection_of_object_values("inclusions", self.inclusions)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/policy_location.py

@@ -0,0 +1,84 @@
+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 .policy_location_application import PolicyLocationApplication
+    from .policy_location_domain import PolicyLocationDomain
+    from .policy_location_url import PolicyLocationUrl
+
+@dataclass
+class PolicyLocation(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
+    # The actual value representing the location. Location value is specific for concretetype of the  policyLocation - policyLocationDomain, policyLocationUrl, or policyLocationApplication (for example, 'contoso.com', 'https://partner.contoso.com/upload', '83ef198a-0396-4893-9d4f-d36efbffcaaa').
+    value: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PolicyLocation:
+        """
+        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: PolicyLocation
+        """
+        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.policyLocationApplication".casefold():
+            from .policy_location_application import PolicyLocationApplication
+
+            return PolicyLocationApplication()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.policyLocationDomain".casefold():
+            from .policy_location_domain import PolicyLocationDomain
+
+            return PolicyLocationDomain()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.policyLocationUrl".casefold():
+            from .policy_location_url import PolicyLocationUrl
+
+            return PolicyLocationUrl()
+        return PolicyLocation()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .policy_location_application import PolicyLocationApplication
+        from .policy_location_domain import PolicyLocationDomain
+        from .policy_location_url import PolicyLocationUrl
+
+        from .policy_location_application import PolicyLocationApplication
+        from .policy_location_domain import PolicyLocationDomain
+        from .policy_location_url import PolicyLocationUrl
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "value": lambda n : setattr(self, 'value', 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_str_value("value", self.value)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/policy_location_application.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 .policy_location import PolicyLocation
+
+from .policy_location import PolicyLocation
+
+@dataclass
+class PolicyLocationApplication(PolicyLocation, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.policyLocationApplication"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PolicyLocationApplication:
+        """
+        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: PolicyLocationApplication
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PolicyLocationApplication()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .policy_location import PolicyLocation
+
+        from .policy_location import PolicyLocation
+
+        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/policy_location_domain.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 .policy_location import PolicyLocation
+
+from .policy_location import PolicyLocation
+
+@dataclass
+class PolicyLocationDomain(PolicyLocation, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.policyLocationDomain"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PolicyLocationDomain:
+        """
+        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: PolicyLocationDomain
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PolicyLocationDomain()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .policy_location import PolicyLocation
+
+        from .policy_location import PolicyLocation
+
+        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/policy_location_url.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 .policy_location import PolicyLocation
+
+from .policy_location import PolicyLocation
+
+@dataclass
+class PolicyLocationUrl(PolicyLocation, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.policyLocationUrl"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PolicyLocationUrl:
+        """
+        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: PolicyLocationUrl
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PolicyLocationUrl()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .policy_location import PolicyLocation
+
+        from .policy_location import PolicyLocation
+
+        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/policy_pivot_property.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class PolicyPivotProperty(str, Enum):
+    None_ = "none",
+    Activity = "activity",
+    Location = "location",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/policy_scope_base.py

@@ -0,0 +1,101 @@
+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_info import DlpActionInfo
+    from .execution_mode import ExecutionMode
+    from .policy_location import PolicyLocation
+    from .policy_tenant_scope import PolicyTenantScope
+    from .policy_user_scope import PolicyUserScope
+    from .user_activity_types import UserActivityTypes
+
+@dataclass
+class PolicyScopeBase(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 activities property
+    activities: Optional[UserActivityTypes] = None
+    # The executionMode property
+    execution_mode: Optional[ExecutionMode] = None
+    # The locations (like domains or URLs) to be protected. Required.
+    locations: Optional[list[PolicyLocation]] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The enforcement actions to take if the policy conditions are met within this scope. Required.
+    policy_actions: Optional[list[DlpActionInfo]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PolicyScopeBase:
+        """
+        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: PolicyScopeBase
+        """
+        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.policyTenantScope".casefold():
+            from .policy_tenant_scope import PolicyTenantScope
+
+            return PolicyTenantScope()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.policyUserScope".casefold():
+            from .policy_user_scope import PolicyUserScope
+
+            return PolicyUserScope()
+        return PolicyScopeBase()
+    
+    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_info import DlpActionInfo
+        from .execution_mode import ExecutionMode
+        from .policy_location import PolicyLocation
+        from .policy_tenant_scope import PolicyTenantScope
+        from .policy_user_scope import PolicyUserScope
+        from .user_activity_types import UserActivityTypes
+
+        from .dlp_action_info import DlpActionInfo
+        from .execution_mode import ExecutionMode
+        from .policy_location import PolicyLocation
+        from .policy_tenant_scope import PolicyTenantScope
+        from .policy_user_scope import PolicyUserScope
+        from .user_activity_types import UserActivityTypes
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "activities": lambda n : setattr(self, 'activities', n.get_collection_of_enum_values(UserActivityTypes)),
+            "executionMode": lambda n : setattr(self, 'execution_mode', n.get_enum_value(ExecutionMode)),
+            "locations": lambda n : setattr(self, 'locations', n.get_collection_of_object_values(PolicyLocation)),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "policyActions": lambda n : setattr(self, 'policy_actions', n.get_collection_of_object_values(DlpActionInfo)),
+        }
+        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("activities", self.activities)
+        writer.write_enum_value("executionMode", self.execution_mode)
+        writer.write_collection_of_object_values("locations", self.locations)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_collection_of_object_values("policyActions", self.policy_actions)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/policy_tenant_scope.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .policy_binding import PolicyBinding
+    from .policy_scope_base import PolicyScopeBase
+
+from .policy_scope_base import PolicyScopeBase
+
+@dataclass
+class PolicyTenantScope(PolicyScopeBase, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.policyTenantScope"
+    # Specifies the users and groups included in or excluded from this tenant-level policy scope.
+    policy_scope: Optional[PolicyBinding] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PolicyTenantScope:
+        """
+        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: PolicyTenantScope
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PolicyTenantScope()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .policy_binding import PolicyBinding
+        from .policy_scope_base import PolicyScopeBase
+
+        from .policy_binding import PolicyBinding
+        from .policy_scope_base import PolicyScopeBase
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "policyScope": lambda n : setattr(self, 'policy_scope', n.get_object_value(PolicyBinding)),
+        }
+        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("policyScope", self.policy_scope)
+    
+