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

msgraph/generated/models/security/user.py

@@ -0,0 +1,61 @@
+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 .identity_accounts import IdentityAccounts
+
+from .identity_accounts import IdentityAccounts
+
+@dataclass
+class User(IdentityAccounts, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.security.user"
+    # Email address of the user.
+    email_address: Optional[str] = None
+    # The user principal name.
+    user_principal_name: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> User:
+        """
+        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: User
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return User()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .identity_accounts import IdentityAccounts
+
+        from .identity_accounts import IdentityAccounts
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "emailAddress": lambda n : setattr(self, 'email_address', n.get_str_value()),
+            "userPrincipalName": lambda n : setattr(self, 'user_principal_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("emailAddress", self.email_address)
+        writer.write_str_value("userPrincipalName", self.user_principal_name)
+    
+

msgraph/generated/models/service_principal_risk_detection.py

@@ -19,7 +19,7 @@ from .entity import Entity
 
 @dataclass
 class ServicePrincipalRiskDetection(Entity, Parsable):
-    # Indicates the activity type the detected risk is linked to.  The possible values are: signin, servicePrincipal. Use the Prefer: include-unknown-enum-members request header to get the following value(s) in this evolvable enum: servicePrincipal.
+    # Indicates the activity type the detected risk is linked to.  The possible values are: signin, servicePrincipal. Use the Prefer: include-unknown-enum-members request header to get the following members in this evolvable enum: servicePrincipal.
     activity: Optional[ActivityType] = None
     # Date and time when the risky activity occurred. The DateTimeOffset type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z
     activity_date_time: Optional[datetime.datetime] = None
@@ -45,7 +45,7 @@ class ServicePrincipalRiskDetection(Entity, Parsable):
     odata_type: Optional[str] = None
     # Request identifier of the sign-in activity associated with the risk detection. This property is null if the risk detection is not associated with a sign-in activity. Supports $filter (eq).
     request_id: Optional[str] = None
-    # Details of the detected risk. Note: Details for this property are only available for Workload Identities Premium customers. Events in tenants without this license will be returned hidden. The possible values are: none, hidden, adminConfirmedServicePrincipalCompromised, adminDismissedAllRiskForServicePrincipal. Use the Prefer: include-unknown-enum-members request header to get the following value(s) in this evolvable enum: adminConfirmedServicePrincipalCompromised , adminDismissedAllRiskForServicePrincipal.
+    # Details of the detected risk. Note: Details for this property are only available for Workload Identities Premium customers. Events in tenants without this license will be returned hidden.
     risk_detail: Optional[RiskDetail] = None
     # The type of risk event detected. The possible values are: investigationsThreatIntelligence, generic, adminConfirmedServicePrincipalCompromised, suspiciousSignins, leakedCredentials, anomalousServicePrincipalActivity, maliciousApplication, suspiciousApplication.
     risk_event_type: Optional[str] = None

msgraph/generated/models/share_point_migration_container_info.py

@@ -0,0 +1,62 @@
+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 SharePointMigrationContainerInfo(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)
+    # A valid URL with a SAS token for accessing the Azure blob storage container that contains the file content. Read-only.
+    data_container_uri: Optional[str] = None
+    # Provides the AES-256-CBC encryption key if files stored in Azure blob containers are encrypted. The key is Base64-encoded. Read-only.
+    encryption_key: Optional[str] = None
+    # A valid URL with a SAS token for accessing the Azure blob storage container that contains the file metadata. Read-only.
+    metadata_container_uri: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SharePointMigrationContainerInfo:
+        """
+        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: SharePointMigrationContainerInfo
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SharePointMigrationContainerInfo()
+    
+    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]] = {
+            "dataContainerUri": lambda n : setattr(self, 'data_container_uri', n.get_str_value()),
+            "encryptionKey": lambda n : setattr(self, 'encryption_key', n.get_str_value()),
+            "metadataContainerUri": lambda n : setattr(self, 'metadata_container_uri', n.get_str_value()),
+            "@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("dataContainerUri", self.data_container_uri)
+        writer.write_str_value("encryptionKey", self.encryption_key)
+        writer.write_str_value("metadataContainerUri", self.metadata_container_uri)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/share_point_migration_event.py

@@ -0,0 +1,127 @@
+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 .entity import Entity
+    from .share_point_migration_finish_manifest_file_upload_event import SharePointMigrationFinishManifestFileUploadEvent
+    from .share_point_migration_job_cancelled_event import SharePointMigrationJobCancelledEvent
+    from .share_point_migration_job_deleted_event import SharePointMigrationJobDeletedEvent
+    from .share_point_migration_job_error_event import SharePointMigrationJobErrorEvent
+    from .share_point_migration_job_postponed_event import SharePointMigrationJobPostponedEvent
+    from .share_point_migration_job_progress_event import SharePointMigrationJobProgressEvent
+    from .share_point_migration_job_queued_event import SharePointMigrationJobQueuedEvent
+    from .share_point_migration_job_start_event import SharePointMigrationJobStartEvent
+
+from .entity import Entity
+
+@dataclass
+class SharePointMigrationEvent(Entity, Parsable):
+    # The correlation ID of a migration job. Read-only.
+    correlation_id: Optional[str] = None
+    # The date and time when the job status changes. The timestamp type represents date and time information using ISO 8601 format and is always in UTC. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z. Read-only.
+    event_date_time: Optional[datetime.datetime] = None
+    # The unique identifier of a migration job. Read-only.
+    job_id: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SharePointMigrationEvent:
+        """
+        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: SharePointMigrationEvent
+        """
+        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.sharePointMigrationFinishManifestFileUploadEvent".casefold():
+            from .share_point_migration_finish_manifest_file_upload_event import SharePointMigrationFinishManifestFileUploadEvent
+
+            return SharePointMigrationFinishManifestFileUploadEvent()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.sharePointMigrationJobCancelledEvent".casefold():
+            from .share_point_migration_job_cancelled_event import SharePointMigrationJobCancelledEvent
+
+            return SharePointMigrationJobCancelledEvent()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.sharePointMigrationJobDeletedEvent".casefold():
+            from .share_point_migration_job_deleted_event import SharePointMigrationJobDeletedEvent
+
+            return SharePointMigrationJobDeletedEvent()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.sharePointMigrationJobErrorEvent".casefold():
+            from .share_point_migration_job_error_event import SharePointMigrationJobErrorEvent
+
+            return SharePointMigrationJobErrorEvent()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.sharePointMigrationJobPostponedEvent".casefold():
+            from .share_point_migration_job_postponed_event import SharePointMigrationJobPostponedEvent
+
+            return SharePointMigrationJobPostponedEvent()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.sharePointMigrationJobProgressEvent".casefold():
+            from .share_point_migration_job_progress_event import SharePointMigrationJobProgressEvent
+
+            return SharePointMigrationJobProgressEvent()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.sharePointMigrationJobQueuedEvent".casefold():
+            from .share_point_migration_job_queued_event import SharePointMigrationJobQueuedEvent
+
+            return SharePointMigrationJobQueuedEvent()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.sharePointMigrationJobStartEvent".casefold():
+            from .share_point_migration_job_start_event import SharePointMigrationJobStartEvent
+
+            return SharePointMigrationJobStartEvent()
+        return SharePointMigrationEvent()
+    
+    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 .share_point_migration_finish_manifest_file_upload_event import SharePointMigrationFinishManifestFileUploadEvent
+        from .share_point_migration_job_cancelled_event import SharePointMigrationJobCancelledEvent
+        from .share_point_migration_job_deleted_event import SharePointMigrationJobDeletedEvent
+        from .share_point_migration_job_error_event import SharePointMigrationJobErrorEvent
+        from .share_point_migration_job_postponed_event import SharePointMigrationJobPostponedEvent
+        from .share_point_migration_job_progress_event import SharePointMigrationJobProgressEvent
+        from .share_point_migration_job_queued_event import SharePointMigrationJobQueuedEvent
+        from .share_point_migration_job_start_event import SharePointMigrationJobStartEvent
+
+        from .entity import Entity
+        from .share_point_migration_finish_manifest_file_upload_event import SharePointMigrationFinishManifestFileUploadEvent
+        from .share_point_migration_job_cancelled_event import SharePointMigrationJobCancelledEvent
+        from .share_point_migration_job_deleted_event import SharePointMigrationJobDeletedEvent
+        from .share_point_migration_job_error_event import SharePointMigrationJobErrorEvent
+        from .share_point_migration_job_postponed_event import SharePointMigrationJobPostponedEvent
+        from .share_point_migration_job_progress_event import SharePointMigrationJobProgressEvent
+        from .share_point_migration_job_queued_event import SharePointMigrationJobQueuedEvent
+        from .share_point_migration_job_start_event import SharePointMigrationJobStartEvent
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "correlationId": lambda n : setattr(self, 'correlation_id', n.get_str_value()),
+            "eventDateTime": lambda n : setattr(self, 'event_date_time', n.get_datetime_value()),
+            "jobId": lambda n : setattr(self, 'job_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("correlationId", self.correlation_id)
+        writer.write_datetime_value("eventDateTime", self.event_date_time)
+        writer.write_str_value("jobId", self.job_id)
+    
+

msgraph/generated/models/share_point_migration_event_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 .share_point_migration_event import SharePointMigrationEvent
+
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+
+@dataclass
+class SharePointMigrationEventCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[list[SharePointMigrationEvent]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SharePointMigrationEventCollectionResponse:
+        """
+        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: SharePointMigrationEventCollectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SharePointMigrationEventCollectionResponse()
+    
+    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 .share_point_migration_event import SharePointMigrationEvent
+
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .share_point_migration_event import SharePointMigrationEvent
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(SharePointMigrationEvent)),
+        }
+        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/share_point_migration_finish_manifest_file_upload_event.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 .share_point_migration_event import SharePointMigrationEvent
+
+from .share_point_migration_event import SharePointMigrationEvent
+
+@dataclass
+class SharePointMigrationFinishManifestFileUploadEvent(SharePointMigrationEvent, Parsable):
+    # The exported manifest file name. Read-only.
+    manifest_file_name: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SharePointMigrationFinishManifestFileUploadEvent:
+        """
+        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: SharePointMigrationFinishManifestFileUploadEvent
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SharePointMigrationFinishManifestFileUploadEvent()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .share_point_migration_event import SharePointMigrationEvent
+
+        from .share_point_migration_event import SharePointMigrationEvent
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "manifestFileName": lambda n : setattr(self, 'manifest_file_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("manifestFileName", self.manifest_file_name)
+    
+

msgraph/generated/models/share_point_migration_job.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 .entity import Entity
+    from .share_point_migration_container_info import SharePointMigrationContainerInfo
+    from .share_point_migration_event import SharePointMigrationEvent
+
+from .entity import Entity
+
+@dataclass
+class SharePointMigrationJob(Entity, Parsable):
+    # The containerInfo property
+    container_info: Optional[SharePointMigrationContainerInfo] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # A collection of migration events that reflects the job status changes.
+    progress_events: Optional[list[SharePointMigrationEvent]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SharePointMigrationJob:
+        """
+        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: SharePointMigrationJob
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SharePointMigrationJob()
+    
+    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 .share_point_migration_container_info import SharePointMigrationContainerInfo
+        from .share_point_migration_event import SharePointMigrationEvent
+
+        from .entity import Entity
+        from .share_point_migration_container_info import SharePointMigrationContainerInfo
+        from .share_point_migration_event import SharePointMigrationEvent
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "containerInfo": lambda n : setattr(self, 'container_info', n.get_object_value(SharePointMigrationContainerInfo)),
+            "progressEvents": lambda n : setattr(self, 'progress_events', n.get_collection_of_object_values(SharePointMigrationEvent)),
+        }
+        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("containerInfo", self.container_info)
+        writer.write_collection_of_object_values("progressEvents", self.progress_events)
+    
+

msgraph/generated/models/share_point_migration_job_cancelled_event.py

@@ -0,0 +1,61 @@
+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 .share_point_migration_event import SharePointMigrationEvent
+
+from .share_point_migration_event import SharePointMigrationEvent
+
+@dataclass
+class SharePointMigrationJobCancelledEvent(SharePointMigrationEvent, Parsable):
+    # True when a user cancels the job; otherwise, false. Read-only.
+    is_cancelled_by_user: Optional[bool] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The current retry count of the job. Read-only.
+    total_retry_count: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SharePointMigrationJobCancelledEvent:
+        """
+        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: SharePointMigrationJobCancelledEvent
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SharePointMigrationJobCancelledEvent()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .share_point_migration_event import SharePointMigrationEvent
+
+        from .share_point_migration_event import SharePointMigrationEvent
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "isCancelledByUser": lambda n : setattr(self, 'is_cancelled_by_user', n.get_bool_value()),
+            "totalRetryCount": lambda n : setattr(self, 'total_retry_count', 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_bool_value("isCancelledByUser", self.is_cancelled_by_user)
+        writer.write_int_value("totalRetryCount", self.total_retry_count)
+    
+

msgraph/generated/models/share_point_migration_job_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 .share_point_migration_job import SharePointMigrationJob
+
+from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+
+@dataclass
+class SharePointMigrationJobCollectionResponse(BaseCollectionPaginationCountResponse, Parsable):
+    # The value property
+    value: Optional[list[SharePointMigrationJob]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SharePointMigrationJobCollectionResponse:
+        """
+        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: SharePointMigrationJobCollectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SharePointMigrationJobCollectionResponse()
+    
+    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 .share_point_migration_job import SharePointMigrationJob
+
+        from .base_collection_pagination_count_response import BaseCollectionPaginationCountResponse
+        from .share_point_migration_job import SharePointMigrationJob
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(SharePointMigrationJob)),
+        }
+        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/share_point_migration_job_deleted_event.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 .share_point_migration_event import SharePointMigrationEvent
+
+from .share_point_migration_event import SharePointMigrationEvent
+
+@dataclass
+class SharePointMigrationJobDeletedEvent(SharePointMigrationEvent, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SharePointMigrationJobDeletedEvent:
+        """
+        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: SharePointMigrationJobDeletedEvent
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SharePointMigrationJobDeletedEvent()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .share_point_migration_event import SharePointMigrationEvent
+
+        from .share_point_migration_event import SharePointMigrationEvent
+
+        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)
+    
+