msgraph-sdk 1.28.0__py3-none-any.whl → 1.30.0__py3-none-any.whl

msgraph/generated/models/on_attribute_collection_start_listener.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 .authentication_event_listener import AuthenticationEventListener
+    from .on_attribute_collection_start_handler import OnAttributeCollectionStartHandler
+
+from .authentication_event_listener import AuthenticationEventListener
+
+@dataclass
+class OnAttributeCollectionStartListener(AuthenticationEventListener, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.onAttributeCollectionStartListener"
+    # Configuration for what to invoke if the event resolves to this listener.
+    handler: Optional[OnAttributeCollectionStartHandler] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> OnAttributeCollectionStartListener:
+        """
+        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: OnAttributeCollectionStartListener
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return OnAttributeCollectionStartListener()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .authentication_event_listener import AuthenticationEventListener
+        from .on_attribute_collection_start_handler import OnAttributeCollectionStartHandler
+
+        from .authentication_event_listener import AuthenticationEventListener
+        from .on_attribute_collection_start_handler import OnAttributeCollectionStartHandler
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "handler": lambda n : setattr(self, 'handler', n.get_object_value(OnAttributeCollectionStartHandler)),
+        }
+        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("handler", self.handler)
+    
+

msgraph/generated/models/on_attribute_collection_submit_custom_extension.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 .custom_authentication_extension import CustomAuthenticationExtension
+
+from .custom_authentication_extension import CustomAuthenticationExtension
+
+@dataclass
+class OnAttributeCollectionSubmitCustomExtension(CustomAuthenticationExtension, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.onAttributeCollectionSubmitCustomExtension"
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> OnAttributeCollectionSubmitCustomExtension:
+        """
+        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: OnAttributeCollectionSubmitCustomExtension
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return OnAttributeCollectionSubmitCustomExtension()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .custom_authentication_extension import CustomAuthenticationExtension
+
+        from .custom_authentication_extension import CustomAuthenticationExtension
+
+        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/on_attribute_collection_submit_custom_extension_handler.py

@@ -0,0 +1,67 @@
+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 .custom_extension_overwrite_configuration import CustomExtensionOverwriteConfiguration
+    from .on_attribute_collection_submit_custom_extension import OnAttributeCollectionSubmitCustomExtension
+    from .on_attribute_collection_submit_handler import OnAttributeCollectionSubmitHandler
+
+from .on_attribute_collection_submit_handler import OnAttributeCollectionSubmitHandler
+
+@dataclass
+class OnAttributeCollectionSubmitCustomExtensionHandler(OnAttributeCollectionSubmitHandler, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.onAttributeCollectionSubmitCustomExtensionHandler"
+    # Configuration regarding properties of the custom extension that can be overwritten per event listener.
+    configuration: Optional[CustomExtensionOverwriteConfiguration] = None
+    # The customExtension property
+    custom_extension: Optional[OnAttributeCollectionSubmitCustomExtension] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> OnAttributeCollectionSubmitCustomExtensionHandler:
+        """
+        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: OnAttributeCollectionSubmitCustomExtensionHandler
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return OnAttributeCollectionSubmitCustomExtensionHandler()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .custom_extension_overwrite_configuration import CustomExtensionOverwriteConfiguration
+        from .on_attribute_collection_submit_custom_extension import OnAttributeCollectionSubmitCustomExtension
+        from .on_attribute_collection_submit_handler import OnAttributeCollectionSubmitHandler
+
+        from .custom_extension_overwrite_configuration import CustomExtensionOverwriteConfiguration
+        from .on_attribute_collection_submit_custom_extension import OnAttributeCollectionSubmitCustomExtension
+        from .on_attribute_collection_submit_handler import OnAttributeCollectionSubmitHandler
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "configuration": lambda n : setattr(self, 'configuration', n.get_object_value(CustomExtensionOverwriteConfiguration)),
+            "customExtension": lambda n : setattr(self, 'custom_extension', n.get_object_value(OnAttributeCollectionSubmitCustomExtension)),
+        }
+        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("configuration", self.configuration)
+        writer.write_object_value("customExtension", self.custom_extension)
+    
+

msgraph/generated/models/on_attribute_collection_submit_handler.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 .on_attribute_collection_submit_custom_extension_handler import OnAttributeCollectionSubmitCustomExtensionHandler
+
+@dataclass
+class OnAttributeCollectionSubmitHandler(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) -> OnAttributeCollectionSubmitHandler:
+        """
+        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: OnAttributeCollectionSubmitHandler
+        """
+        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.onAttributeCollectionSubmitCustomExtensionHandler".casefold():
+            from .on_attribute_collection_submit_custom_extension_handler import OnAttributeCollectionSubmitCustomExtensionHandler
+
+            return OnAttributeCollectionSubmitCustomExtensionHandler()
+        return OnAttributeCollectionSubmitHandler()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .on_attribute_collection_submit_custom_extension_handler import OnAttributeCollectionSubmitCustomExtensionHandler
+
+        from .on_attribute_collection_submit_custom_extension_handler import OnAttributeCollectionSubmitCustomExtensionHandler
+
+        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/on_attribute_collection_submit_listener.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 .authentication_event_listener import AuthenticationEventListener
+    from .on_attribute_collection_submit_handler import OnAttributeCollectionSubmitHandler
+
+from .authentication_event_listener import AuthenticationEventListener
+
+@dataclass
+class OnAttributeCollectionSubmitListener(AuthenticationEventListener, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.onAttributeCollectionSubmitListener"
+    # Configuration for what to invoke if the event resolves to this listener.
+    handler: Optional[OnAttributeCollectionSubmitHandler] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> OnAttributeCollectionSubmitListener:
+        """
+        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: OnAttributeCollectionSubmitListener
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return OnAttributeCollectionSubmitListener()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .authentication_event_listener import AuthenticationEventListener
+        from .on_attribute_collection_submit_handler import OnAttributeCollectionSubmitHandler
+
+        from .authentication_event_listener import AuthenticationEventListener
+        from .on_attribute_collection_submit_handler import OnAttributeCollectionSubmitHandler
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "handler": lambda n : setattr(self, 'handler', n.get_object_value(OnAttributeCollectionSubmitHandler)),
+        }
+        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("handler", self.handler)
+    
+

msgraph/generated/models/one_drive_for_business_protection_policy.py

@@ -7,6 +7,7 @@ from typing import Any, Optional, TYPE_CHECKING, Union
 if TYPE_CHECKING:
     from .drive_protection_rule import DriveProtectionRule
     from .drive_protection_unit import DriveProtectionUnit
+    from .drive_protection_units_bulk_addition_job import DriveProtectionUnitsBulkAdditionJob
     from .protection_policy_base import ProtectionPolicyBase
 
 from .protection_policy_base import ProtectionPolicyBase
@@ -19,6 +20,8 @@ class OneDriveForBusinessProtectionPolicy(ProtectionPolicyBase, Parsable):
     drive_inclusion_rules: Optional[list[DriveProtectionRule]] = None
     # Contains the protection units associated with a  OneDrive for Business protection policy.
     drive_protection_units: Optional[list[DriveProtectionUnit]] = None
+    # The driveProtectionUnitsBulkAdditionJobs property
+    drive_protection_units_bulk_addition_jobs: Optional[list[DriveProtectionUnitsBulkAdditionJob]] = None
     
     @staticmethod
     def create_from_discriminator_value(parse_node: ParseNode) -> OneDriveForBusinessProtectionPolicy:
@@ -38,15 +41,18 @@ class OneDriveForBusinessProtectionPolicy(ProtectionPolicyBase, Parsable):
         """
         from .drive_protection_rule import DriveProtectionRule
         from .drive_protection_unit import DriveProtectionUnit
+        from .drive_protection_units_bulk_addition_job import DriveProtectionUnitsBulkAdditionJob
         from .protection_policy_base import ProtectionPolicyBase
 
         from .drive_protection_rule import DriveProtectionRule
         from .drive_protection_unit import DriveProtectionUnit
+        from .drive_protection_units_bulk_addition_job import DriveProtectionUnitsBulkAdditionJob
         from .protection_policy_base import ProtectionPolicyBase
 
         fields: dict[str, Callable[[Any], None]] = {
             "driveInclusionRules": lambda n : setattr(self, 'drive_inclusion_rules', n.get_collection_of_object_values(DriveProtectionRule)),
             "driveProtectionUnits": lambda n : setattr(self, 'drive_protection_units', n.get_collection_of_object_values(DriveProtectionUnit)),
+            "driveProtectionUnitsBulkAdditionJobs": lambda n : setattr(self, 'drive_protection_units_bulk_addition_jobs', n.get_collection_of_object_values(DriveProtectionUnitsBulkAdditionJob)),
         }
         super_fields = super().get_field_deserializers()
         fields.update(super_fields)
@@ -63,5 +69,6 @@ class OneDriveForBusinessProtectionPolicy(ProtectionPolicyBase, Parsable):
         super().serialize(writer)
         writer.write_collection_of_object_values("driveInclusionRules", self.drive_inclusion_rules)
         writer.write_collection_of_object_values("driveProtectionUnits", self.drive_protection_units)
+        writer.write_collection_of_object_values("driveProtectionUnitsBulkAdditionJobs", self.drive_protection_units_bulk_addition_jobs)
     
 

msgraph/generated/models/one_drive_for_business_restore_session.py

@@ -6,6 +6,7 @@ from typing import Any, Optional, TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
     from .drive_restore_artifact import DriveRestoreArtifact
+    from .drive_restore_artifacts_bulk_addition_request import DriveRestoreArtifactsBulkAdditionRequest
     from .restore_session_base import RestoreSessionBase
 
 from .restore_session_base import RestoreSessionBase
@@ -16,6 +17,8 @@ class OneDriveForBusinessRestoreSession(RestoreSessionBase, Parsable):
     odata_type: Optional[str] = "#microsoft.graph.oneDriveForBusinessRestoreSession"
     # A collection of restore points and destination details that can be used to restore a OneDrive for Business drive.
     drive_restore_artifacts: Optional[list[DriveRestoreArtifact]] = None
+    # The driveRestoreArtifactsBulkAdditionRequests property
+    drive_restore_artifacts_bulk_addition_requests: Optional[list[DriveRestoreArtifactsBulkAdditionRequest]] = None
     
     @staticmethod
     def create_from_discriminator_value(parse_node: ParseNode) -> OneDriveForBusinessRestoreSession:
@@ -34,13 +37,16 @@ class OneDriveForBusinessRestoreSession(RestoreSessionBase, Parsable):
         Returns: dict[str, Callable[[ParseNode], None]]
         """
         from .drive_restore_artifact import DriveRestoreArtifact
+        from .drive_restore_artifacts_bulk_addition_request import DriveRestoreArtifactsBulkAdditionRequest
         from .restore_session_base import RestoreSessionBase
 
         from .drive_restore_artifact import DriveRestoreArtifact
+        from .drive_restore_artifacts_bulk_addition_request import DriveRestoreArtifactsBulkAdditionRequest
         from .restore_session_base import RestoreSessionBase
 
         fields: dict[str, Callable[[Any], None]] = {
             "driveRestoreArtifacts": lambda n : setattr(self, 'drive_restore_artifacts', n.get_collection_of_object_values(DriveRestoreArtifact)),
+            "driveRestoreArtifactsBulkAdditionRequests": lambda n : setattr(self, 'drive_restore_artifacts_bulk_addition_requests', n.get_collection_of_object_values(DriveRestoreArtifactsBulkAdditionRequest)),
         }
         super_fields = super().get_field_deserializers()
         fields.update(super_fields)
@@ -56,5 +62,6 @@ class OneDriveForBusinessRestoreSession(RestoreSessionBase, Parsable):
             raise TypeError("writer cannot be null.")
         super().serialize(writer)
         writer.write_collection_of_object_values("driveRestoreArtifacts", self.drive_restore_artifacts)
+        writer.write_collection_of_object_values("driveRestoreArtifactsBulkAdditionRequests", self.drive_restore_artifacts_bulk_addition_requests)
     
 

msgraph/generated/models/platform_credential_authentication_method.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+import datetime
+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 .authentication_method import AuthenticationMethod
+    from .authentication_method_key_strength import AuthenticationMethodKeyStrength
+    from .authentication_method_platform import AuthenticationMethodPlatform
+    from .device import Device
+
+from .authentication_method import AuthenticationMethod
+
+@dataclass
+class PlatformCredentialAuthenticationMethod(AuthenticationMethod, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.platformCredentialAuthenticationMethod"
+    # The date and time that this Platform Credential Key was registered.
+    created_date_time: Optional[datetime.datetime] = None
+    # The registered device on which this Platform Credential resides. Supports $expand. When you get a user's Platform Credential registration information, this property is returned only on a single GET and when you specify ?$expand. For example, GET /users/admin@contoso.com/authentication/platformCredentialAuthenticationMethod/_jpuR-TGZtk6aQCLF3BQjA2?$expand=device.
+    device: Optional[Device] = None
+    # The name of the device on which Platform Credential is registered.
+    display_name: Optional[str] = None
+    # Key strength of this Platform Credential key. Possible values are: normal, weak, unknown.
+    key_strength: Optional[AuthenticationMethodKeyStrength] = None
+    # Platform on which this Platform Credential key is present. Possible values are: unknown, windows, macOS,iOS, android, linux.
+    platform: Optional[AuthenticationMethodPlatform] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PlatformCredentialAuthenticationMethod:
+        """
+        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: PlatformCredentialAuthenticationMethod
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PlatformCredentialAuthenticationMethod()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .authentication_method import AuthenticationMethod
+        from .authentication_method_key_strength import AuthenticationMethodKeyStrength
+        from .authentication_method_platform import AuthenticationMethodPlatform
+        from .device import Device
+
+        from .authentication_method import AuthenticationMethod
+        from .authentication_method_key_strength import AuthenticationMethodKeyStrength
+        from .authentication_method_platform import AuthenticationMethodPlatform
+        from .device import Device
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "createdDateTime": lambda n : setattr(self, 'created_date_time', n.get_datetime_value()),
+            "device": lambda n : setattr(self, 'device', n.get_object_value(Device)),
+            "displayName": lambda n : setattr(self, 'display_name', n.get_str_value()),
+            "keyStrength": lambda n : setattr(self, 'key_strength', n.get_enum_value(AuthenticationMethodKeyStrength)),
+            "platform": lambda n : setattr(self, 'platform', n.get_enum_value(AuthenticationMethodPlatform)),
+        }
+        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_datetime_value("createdDateTime", self.created_date_time)
+        writer.write_object_value("device", self.device)
+        writer.write_str_value("displayName", self.display_name)
+        writer.write_enum_value("keyStrength", self.key_strength)
+        writer.write_enum_value("platform", self.platform)
+    
+

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

@@ -0,0 +1,117 @@
+from __future__ import annotations
+import datetime
+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 .drive_protection_units_bulk_addition_job import DriveProtectionUnitsBulkAdditionJob
+    from .entity import Entity
+    from .identity_set import IdentitySet
+    from .mailbox_protection_units_bulk_addition_job import MailboxProtectionUnitsBulkAdditionJob
+    from .protection_units_bulk_job_status import ProtectionUnitsBulkJobStatus
+    from .public_error import PublicError
+    from .site_protection_units_bulk_addition_job import SiteProtectionUnitsBulkAdditionJob
+
+from .entity import Entity
+
+@dataclass
+class ProtectionUnitsBulkJobBase(Entity, Parsable):
+    # The createdBy property
+    created_by: Optional[IdentitySet] = None
+    # The createdDateTime property
+    created_date_time: Optional[datetime.datetime] = None
+    # The displayName property
+    display_name: Optional[str] = None
+    # The error property
+    error: Optional[PublicError] = None
+    # The lastModifiedBy property
+    last_modified_by: Optional[IdentitySet] = None
+    # The lastModifiedDateTime property
+    last_modified_date_time: Optional[datetime.datetime] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The status property
+    status: Optional[ProtectionUnitsBulkJobStatus] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ProtectionUnitsBulkJobBase:
+        """
+        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: ProtectionUnitsBulkJobBase
+        """
+        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.driveProtectionUnitsBulkAdditionJob".casefold():
+            from .drive_protection_units_bulk_addition_job import DriveProtectionUnitsBulkAdditionJob
+
+            return DriveProtectionUnitsBulkAdditionJob()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.mailboxProtectionUnitsBulkAdditionJob".casefold():
+            from .mailbox_protection_units_bulk_addition_job import MailboxProtectionUnitsBulkAdditionJob
+
+            return MailboxProtectionUnitsBulkAdditionJob()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.siteProtectionUnitsBulkAdditionJob".casefold():
+            from .site_protection_units_bulk_addition_job import SiteProtectionUnitsBulkAdditionJob
+
+            return SiteProtectionUnitsBulkAdditionJob()
+        return ProtectionUnitsBulkJobBase()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .drive_protection_units_bulk_addition_job import DriveProtectionUnitsBulkAdditionJob
+        from .entity import Entity
+        from .identity_set import IdentitySet
+        from .mailbox_protection_units_bulk_addition_job import MailboxProtectionUnitsBulkAdditionJob
+        from .protection_units_bulk_job_status import ProtectionUnitsBulkJobStatus
+        from .public_error import PublicError
+        from .site_protection_units_bulk_addition_job import SiteProtectionUnitsBulkAdditionJob
+
+        from .drive_protection_units_bulk_addition_job import DriveProtectionUnitsBulkAdditionJob
+        from .entity import Entity
+        from .identity_set import IdentitySet
+        from .mailbox_protection_units_bulk_addition_job import MailboxProtectionUnitsBulkAdditionJob
+        from .protection_units_bulk_job_status import ProtectionUnitsBulkJobStatus
+        from .public_error import PublicError
+        from .site_protection_units_bulk_addition_job import SiteProtectionUnitsBulkAdditionJob
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "createdBy": lambda n : setattr(self, 'created_by', n.get_object_value(IdentitySet)),
+            "createdDateTime": lambda n : setattr(self, 'created_date_time', n.get_datetime_value()),
+            "displayName": lambda n : setattr(self, 'display_name', n.get_str_value()),
+            "error": lambda n : setattr(self, 'error', n.get_object_value(PublicError)),
+            "lastModifiedBy": lambda n : setattr(self, 'last_modified_by', n.get_object_value(IdentitySet)),
+            "lastModifiedDateTime": lambda n : setattr(self, 'last_modified_date_time', n.get_datetime_value()),
+            "status": lambda n : setattr(self, 'status', n.get_enum_value(ProtectionUnitsBulkJobStatus)),
+        }
+        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("createdBy", self.created_by)
+        writer.write_datetime_value("createdDateTime", self.created_date_time)
+        writer.write_str_value("displayName", self.display_name)
+        writer.write_object_value("error", self.error)
+        writer.write_object_value("lastModifiedBy", self.last_modified_by)
+        writer.write_datetime_value("lastModifiedDateTime", self.last_modified_date_time)
+        writer.write_enum_value("status", self.status)
+    
+

msgraph/generated/models/protection_units_bulk_job_status.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class ProtectionUnitsBulkJobStatus(str, Enum):
+    Unknown = "unknown",
+    Active = "active",
+    Completed = "completed",
+    CompletedWithErrors = "completedWithErrors",
+    UnknownFutureValue = "unknownFutureValue",
+