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

msgraph/generated/models/external_connectors/property_.py

@@ -26,7 +26,7 @@ class Property_(AdditionalDataHolder, BackedModel, Parsable):
     is_retrievable: Optional[bool] = None
     # Specifies if the property is searchable. Only properties of type String or StringCollection can be searchable. Nonsearchable properties aren't added to the search index. Optional.
     is_searchable: Optional[bool] = None
-    # Specifies one or more well-known tags added against a property. Labels help Microsoft Search understand the semantics of the data in the connection. Adding appropriate labels would result in an enhanced search experience (for example, better relevance). Optional.The possible values are: title, url, createdBy, lastModifiedBy, authors, createdDateTime, lastModifiedDateTime, fileName, fileExtension, unknownFutureValue, iconUrl. Use the Prefer: include-unknown-enum-members request header to get the following value in this evolvable enum: iconUrl.
+    # Specifies one or more well-known tags added against a property. Labels help Microsoft Search understand the semantics of the data in the connection. Adding appropriate labels would result in an enhanced search experience (for example, better relevance). Optional.The possible values are: title, url, createdBy, lastModifiedBy, authors, createdDateTime, lastModifiedDateTime, fileName, fileExtension, unknownFutureValue, iconUrl. Use the Prefer: include-unknown-enum-members request header to get the following members in this evolvable enum: iconUrl.
     labels: Optional[list[Label]] = None
     # The name of the property. Maximum 32 characters. Only alphanumeric characters allowed. For example, each string may not contain control characters, whitespace, or any of the following: :, ;, ,, (, ), [, ], {, }, %, $, +, !, *, =, &, ?, @, #, /, ~, ', ', <, >, `, ^.  Required.
     name: Optional[str] = None

msgraph/generated/models/file_storage_container.py

@@ -16,6 +16,7 @@ if TYPE_CHECKING:
     from .file_storage_container_viewpoint import FileStorageContainerViewpoint
     from .permission import Permission
     from .recycle_bin import RecycleBin
+    from .share_point_migration_job import SharePointMigrationJob
     from .site_lock_state import SiteLockState
 
 from .entity import Entity
@@ -38,6 +39,8 @@ class FileStorageContainer(Entity, Parsable):
     drive: Optional[Drive] = None
     # Indicates the lock state of the fileStorageContainer. The possible values are unlocked and lockedReadOnly. Read-only.
     lock_state: Optional[SiteLockState] = None
+    # The collection of sharePointMigrationJob objects local to the container. Read-write.
+    migration_jobs: Optional[list[SharePointMigrationJob]] = None
     # The OdataType property
     odata_type: Optional[str] = None
     # The set of permissions for users in the fileStorageContainer. Permission for each user is set by the roles property. The possible values are: reader, writer, manager, and owner. Read-write.
@@ -76,6 +79,7 @@ class FileStorageContainer(Entity, Parsable):
         from .file_storage_container_viewpoint import FileStorageContainerViewpoint
         from .permission import Permission
         from .recycle_bin import RecycleBin
+        from .share_point_migration_job import SharePointMigrationJob
         from .site_lock_state import SiteLockState
 
         from .column_definition import ColumnDefinition
@@ -87,6 +91,7 @@ class FileStorageContainer(Entity, Parsable):
         from .file_storage_container_viewpoint import FileStorageContainerViewpoint
         from .permission import Permission
         from .recycle_bin import RecycleBin
+        from .share_point_migration_job import SharePointMigrationJob
         from .site_lock_state import SiteLockState
 
         fields: dict[str, Callable[[Any], None]] = {
@@ -98,6 +103,7 @@ class FileStorageContainer(Entity, Parsable):
             "displayName": lambda n : setattr(self, 'display_name', n.get_str_value()),
             "drive": lambda n : setattr(self, 'drive', n.get_object_value(Drive)),
             "lockState": lambda n : setattr(self, 'lock_state', n.get_enum_value(SiteLockState)),
+            "migrationJobs": lambda n : setattr(self, 'migration_jobs', n.get_collection_of_object_values(SharePointMigrationJob)),
             "permissions": lambda n : setattr(self, 'permissions', n.get_collection_of_object_values(Permission)),
             "recycleBin": lambda n : setattr(self, 'recycle_bin', n.get_object_value(RecycleBin)),
             "settings": lambda n : setattr(self, 'settings', n.get_object_value(FileStorageContainerSettings)),
@@ -125,6 +131,7 @@ class FileStorageContainer(Entity, Parsable):
         writer.write_str_value("displayName", self.display_name)
         writer.write_object_value("drive", self.drive)
         writer.write_enum_value("lockState", self.lock_state)
+        writer.write_collection_of_object_values("migrationJobs", self.migration_jobs)
         writer.write_collection_of_object_values("permissions", self.permissions)
         writer.write_object_value("recycleBin", self.recycle_bin)
         writer.write_object_value("settings", self.settings)

msgraph/generated/models/fixture_map.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 .base_map_feature import BaseMapFeature
+
+from .base_map_feature import BaseMapFeature
+
+@dataclass
+class FixtureMap(BaseMapFeature, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.fixtureMap"
+    # The placeId property
+    place_id: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> FixtureMap:
+        """
+        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: FixtureMap
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return FixtureMap()
+    
+    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_map_feature import BaseMapFeature
+
+        from .base_map_feature import BaseMapFeature
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "placeId": lambda n : setattr(self, 'place_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_str_value("placeId", self.place_id)
+    
+

msgraph/generated/models/fixture_map_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 .fixture_map import FixtureMap
+
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+
+@dataclass
+class FixtureMapCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[list[FixtureMap]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> FixtureMapCollectionResponse:
+        """
+        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: FixtureMapCollectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return FixtureMapCollectionResponse()
+    
+    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 .fixture_map import FixtureMap
+
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .fixture_map import FixtureMap
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(FixtureMap)),
+        }
+        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/floor.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 .place import Place
+
+from .place import Place
+
+@dataclass
+class Floor(Place, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.floor"
+    # The sortOrder property
+    sort_order: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> Floor:
+        """
+        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: Floor
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return Floor()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .place import Place
+
+        from .place import Place
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "sortOrder": lambda n : setattr(self, 'sort_order', 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)
+        writer.write_int_value("sortOrder", self.sort_order)
+    
+

msgraph/generated/models/floor_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 .floor import Floor
+
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+
+@dataclass
+class FloorCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[list[Floor]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> FloorCollectionResponse:
+        """
+        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: FloorCollectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return FloorCollectionResponse()
+    
+    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 .floor import Floor
+
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .floor import Floor
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(Floor)),
+        }
+        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/footprint_map.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 .base_map_feature import BaseMapFeature
+
+from .base_map_feature import BaseMapFeature
+
+@dataclass
+class FootprintMap(BaseMapFeature, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.footprintMap"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> FootprintMap:
+        """
+        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: FootprintMap
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return FootprintMap()
+    
+    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_map_feature import BaseMapFeature
+
+        from .base_map_feature import BaseMapFeature
+
+        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/footprint_map_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 .footprint_map import FootprintMap
+
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+
+@dataclass
+class FootprintMapCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[list[FootprintMap]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> FootprintMapCollectionResponse:
+        """
+        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: FootprintMapCollectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return FootprintMapCollectionResponse()
+    
+    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 .footprint_map import FootprintMap
+
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .footprint_map import FootprintMap
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(FootprintMap)),
+        }
+        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/fraud_protection_configuration.py

@@ -0,0 +1,66 @@
+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 .fraud_protection_provider_configuration import FraudProtectionProviderConfiguration
+
+@dataclass
+class FraudProtectionConfiguration(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) -> FraudProtectionConfiguration:
+        """
+        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: FraudProtectionConfiguration
+        """
+        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.fraudProtectionProviderConfiguration".casefold():
+            from .fraud_protection_provider_configuration import FraudProtectionProviderConfiguration
+
+            return FraudProtectionProviderConfiguration()
+        return FraudProtectionConfiguration()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .fraud_protection_provider_configuration import FraudProtectionProviderConfiguration
+
+        from .fraud_protection_provider_configuration import FraudProtectionProviderConfiguration
+
+        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/fraud_protection_provider.py

@@ -0,0 +1,76 @@
+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 .arkose_fraud_protection_provider import ArkoseFraudProtectionProvider
+    from .entity import Entity
+    from .human_security_fraud_protection_provider import HumanSecurityFraudProtectionProvider
+
+from .entity import Entity
+
+@dataclass
+class FraudProtectionProvider(Entity, Parsable):
+    # The display name of the fraud protection provider configuration.
+    display_name: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> FraudProtectionProvider:
+        """
+        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: FraudProtectionProvider
+        """
+        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.arkoseFraudProtectionProvider".casefold():
+            from .arkose_fraud_protection_provider import ArkoseFraudProtectionProvider
+
+            return ArkoseFraudProtectionProvider()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.humanSecurityFraudProtectionProvider".casefold():
+            from .human_security_fraud_protection_provider import HumanSecurityFraudProtectionProvider
+
+            return HumanSecurityFraudProtectionProvider()
+        return FraudProtectionProvider()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .arkose_fraud_protection_provider import ArkoseFraudProtectionProvider
+        from .entity import Entity
+        from .human_security_fraud_protection_provider import HumanSecurityFraudProtectionProvider
+
+        from .arkose_fraud_protection_provider import ArkoseFraudProtectionProvider
+        from .entity import Entity
+        from .human_security_fraud_protection_provider import HumanSecurityFraudProtectionProvider
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "displayName": lambda n : setattr(self, 'display_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_str_value("displayName", self.display_name)
+    
+

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

@@ -0,0 +1,60 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .fraud_protection_configuration import FraudProtectionConfiguration
+    from .fraud_protection_provider import FraudProtectionProvider
+
+from .fraud_protection_configuration import FraudProtectionConfiguration
+
+@dataclass
+class FraudProtectionProviderConfiguration(FraudProtectionConfiguration, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.fraudProtectionProviderConfiguration"
+    # The fraudProtectionProvider property
+    fraud_protection_provider: Optional[FraudProtectionProvider] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> FraudProtectionProviderConfiguration:
+        """
+        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: FraudProtectionProviderConfiguration
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return FraudProtectionProviderConfiguration()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .fraud_protection_configuration import FraudProtectionConfiguration
+        from .fraud_protection_provider import FraudProtectionProvider
+
+        from .fraud_protection_configuration import FraudProtectionConfiguration
+        from .fraud_protection_provider import FraudProtectionProvider
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "fraudProtectionProvider": lambda n : setattr(self, 'fraud_protection_provider', n.get_object_value(FraudProtectionProvider)),
+        }
+        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("fraudProtectionProvider", self.fraud_protection_provider)
+    
+