msgraph-sdk 1.45.0__py3-none-any.whl → 1.47.0__py3-none-any.whl

msgraph/generated/models/education_ai_feedback_audience_engagement_settings.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 EducationAiFeedbackAudienceEngagementSettings(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)
+    # Indicates whether the student should receive feedback on their engagement strategies from the AI feedback.
+    are_engagement_strategies_enabled: Optional[bool] = None
+    # Indicates whether the student should receive feedback on their call to action from the AI feedback.
+    is_call_to_action_enabled: Optional[bool] = None
+    # Indicates whether the student should receive feedback on their emotional and intellectual appeal from the AI feedback.
+    is_emotional_and_intellectual_appeal_enabled: Optional[bool] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> EducationAiFeedbackAudienceEngagementSettings:
+        """
+        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: EducationAiFeedbackAudienceEngagementSettings
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return EducationAiFeedbackAudienceEngagementSettings()
+    
+    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]] = {
+            "areEngagementStrategiesEnabled": lambda n : setattr(self, 'are_engagement_strategies_enabled', n.get_bool_value()),
+            "isCallToActionEnabled": lambda n : setattr(self, 'is_call_to_action_enabled', n.get_bool_value()),
+            "isEmotionalAndIntellectualAppealEnabled": lambda n : setattr(self, 'is_emotional_and_intellectual_appeal_enabled', n.get_bool_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_bool_value("areEngagementStrategiesEnabled", self.are_engagement_strategies_enabled)
+        writer.write_bool_value("isCallToActionEnabled", self.is_call_to_action_enabled)
+        writer.write_bool_value("isEmotionalAndIntellectualAppealEnabled", self.is_emotional_and_intellectual_appeal_enabled)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/education_ai_feedback_content_settings.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 EducationAiFeedbackContentSettings(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)
+    # Indicates whether the student should receive feedback on their message clarity from the AI feedback.
+    is_message_clarity_enabled: Optional[bool] = None
+    # Indicates whether the student should receive feedback on their quality of information from the AI feedback.
+    is_quality_of_information_enabled: Optional[bool] = None
+    # Indicates whether the student should receive feedback on their speech organization from the AI feedback.
+    is_speech_organization_enabled: Optional[bool] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> EducationAiFeedbackContentSettings:
+        """
+        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: EducationAiFeedbackContentSettings
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return EducationAiFeedbackContentSettings()
+    
+    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]] = {
+            "isMessageClarityEnabled": lambda n : setattr(self, 'is_message_clarity_enabled', n.get_bool_value()),
+            "isQualityOfInformationEnabled": lambda n : setattr(self, 'is_quality_of_information_enabled', n.get_bool_value()),
+            "isSpeechOrganizationEnabled": lambda n : setattr(self, 'is_speech_organization_enabled', n.get_bool_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_bool_value("isMessageClarityEnabled", self.is_message_clarity_enabled)
+        writer.write_bool_value("isQualityOfInformationEnabled", self.is_quality_of_information_enabled)
+        writer.write_bool_value("isSpeechOrganizationEnabled", self.is_speech_organization_enabled)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/education_ai_feedback_criteria.py

@@ -0,0 +1,68 @@
+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 .education_ai_feedback_settings import EducationAiFeedbackSettings
+    from .education_speech_type import EducationSpeechType
+
+@dataclass
+class EducationAiFeedbackCriteria(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 aiFeedbackSettings property
+    ai_feedback_settings: Optional[EducationAiFeedbackSettings] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # The speechType property
+    speech_type: Optional[EducationSpeechType] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> EducationAiFeedbackCriteria:
+        """
+        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: EducationAiFeedbackCriteria
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return EducationAiFeedbackCriteria()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .education_ai_feedback_settings import EducationAiFeedbackSettings
+        from .education_speech_type import EducationSpeechType
+
+        from .education_ai_feedback_settings import EducationAiFeedbackSettings
+        from .education_speech_type import EducationSpeechType
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "aiFeedbackSettings": lambda n : setattr(self, 'ai_feedback_settings', n.get_object_value(EducationAiFeedbackSettings)),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "speechType": lambda n : setattr(self, 'speech_type', n.get_enum_value(EducationSpeechType)),
+        }
+        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_object_value("aiFeedbackSettings", self.ai_feedback_settings)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_enum_value("speechType", self.speech_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/education_ai_feedback_delivery_settings.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 EducationAiFeedbackDeliverySettings(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)
+    # Indicates whether the student should receive feedback on their rhetorical techniques from the AI feedback.
+    are_rhetorical_techniques_enabled: Optional[bool] = None
+    # Indicates whether the student should receive feedback on their language use from the AI feedback.
+    is_language_use_enabled: Optional[bool] = None
+    # Indicates whether the student should receive feedback on their style from the AI feedback.
+    is_style_enabled: Optional[bool] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> EducationAiFeedbackDeliverySettings:
+        """
+        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: EducationAiFeedbackDeliverySettings
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return EducationAiFeedbackDeliverySettings()
+    
+    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]] = {
+            "areRhetoricalTechniquesEnabled": lambda n : setattr(self, 'are_rhetorical_techniques_enabled', n.get_bool_value()),
+            "isLanguageUseEnabled": lambda n : setattr(self, 'is_language_use_enabled', n.get_bool_value()),
+            "isStyleEnabled": lambda n : setattr(self, 'is_style_enabled', n.get_bool_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_bool_value("areRhetoricalTechniquesEnabled", self.are_rhetorical_techniques_enabled)
+        writer.write_bool_value("isLanguageUseEnabled", self.is_language_use_enabled)
+        writer.write_bool_value("isStyleEnabled", self.is_style_enabled)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/education_ai_feedback_settings.py

@@ -0,0 +1,75 @@
+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 .education_ai_feedback_audience_engagement_settings import EducationAiFeedbackAudienceEngagementSettings
+    from .education_ai_feedback_content_settings import EducationAiFeedbackContentSettings
+    from .education_ai_feedback_delivery_settings import EducationAiFeedbackDeliverySettings
+
+@dataclass
+class EducationAiFeedbackSettings(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 audience engagement related feedback types that students should receive from the AI feedback.
+    audience_engagement_settings: Optional[EducationAiFeedbackAudienceEngagementSettings] = None
+    # The content related feedback types that students should receive from the AI feedback.
+    content_settings: Optional[EducationAiFeedbackContentSettings] = None
+    # The delivery related feedback types that students should receive from the AI feedback.
+    delivery_settings: Optional[EducationAiFeedbackDeliverySettings] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> EducationAiFeedbackSettings:
+        """
+        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: EducationAiFeedbackSettings
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return EducationAiFeedbackSettings()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .education_ai_feedback_audience_engagement_settings import EducationAiFeedbackAudienceEngagementSettings
+        from .education_ai_feedback_content_settings import EducationAiFeedbackContentSettings
+        from .education_ai_feedback_delivery_settings import EducationAiFeedbackDeliverySettings
+
+        from .education_ai_feedback_audience_engagement_settings import EducationAiFeedbackAudienceEngagementSettings
+        from .education_ai_feedback_content_settings import EducationAiFeedbackContentSettings
+        from .education_ai_feedback_delivery_settings import EducationAiFeedbackDeliverySettings
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "audienceEngagementSettings": lambda n : setattr(self, 'audience_engagement_settings', n.get_object_value(EducationAiFeedbackAudienceEngagementSettings)),
+            "contentSettings": lambda n : setattr(self, 'content_settings', n.get_object_value(EducationAiFeedbackContentSettings)),
+            "deliverySettings": lambda n : setattr(self, 'delivery_settings', n.get_object_value(EducationAiFeedbackDeliverySettings)),
+            "@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_object_value("audienceEngagementSettings", self.audience_engagement_settings)
+        writer.write_object_value("contentSettings", self.content_settings)
+        writer.write_object_value("deliverySettings", self.delivery_settings)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/education_assignment_resource.py

@@ -12,6 +12,8 @@ from .entity import Entity
 
 @dataclass
 class EducationAssignmentResource(Entity, Parsable):
+    # A collection of assignment resources that depend on the parent educationAssignmentResource.
+    dependent_resources: Optional[list[EducationAssignmentResource]] = None
     # Indicates whether this resource should be copied to each student submission for modification and submission. Required
     distribute_for_student_work: Optional[bool] = None
     # The OdataType property
@@ -42,6 +44,7 @@ class EducationAssignmentResource(Entity, Parsable):
         from .entity import Entity
 
         fields: dict[str, Callable[[Any], None]] = {
+            "dependentResources": lambda n : setattr(self, 'dependent_resources', n.get_collection_of_object_values(EducationAssignmentResource)),
             "distributeForStudentWork": lambda n : setattr(self, 'distribute_for_student_work', n.get_bool_value()),
             "resource": lambda n : setattr(self, 'resource', n.get_object_value(EducationResource)),
         }
@@ -58,6 +61,7 @@ class EducationAssignmentResource(Entity, Parsable):
         if writer is None:
             raise TypeError("writer cannot be null.")
         super().serialize(writer)
+        writer.write_collection_of_object_values("dependentResources", self.dependent_resources)
         writer.write_bool_value("distributeForStudentWork", self.distribute_for_student_work)
         writer.write_object_value("resource", self.resource)
     

msgraph/generated/models/education_resource.py

@@ -15,6 +15,7 @@ if TYPE_CHECKING:
     from .education_link_resource import EducationLinkResource
     from .education_media_resource import EducationMediaResource
     from .education_power_point_resource import EducationPowerPointResource
+    from .education_speaker_progress_resource import EducationSpeakerProgressResource
     from .education_teams_app_resource import EducationTeamsAppResource
     from .education_word_resource import EducationWordResource
     from .identity_set import IdentitySet
@@ -85,6 +86,10 @@ class EducationResource(AdditionalDataHolder, BackedModel, Parsable):
             from .education_power_point_resource import EducationPowerPointResource
 
             return EducationPowerPointResource()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.educationSpeakerProgressResource".casefold():
+            from .education_speaker_progress_resource import EducationSpeakerProgressResource
+
+            return EducationSpeakerProgressResource()
         if mapping_value and mapping_value.casefold() == "#microsoft.graph.educationTeamsAppResource".casefold():
             from .education_teams_app_resource import EducationTeamsAppResource
 
@@ -108,6 +113,7 @@ class EducationResource(AdditionalDataHolder, BackedModel, Parsable):
         from .education_link_resource import EducationLinkResource
         from .education_media_resource import EducationMediaResource
         from .education_power_point_resource import EducationPowerPointResource
+        from .education_speaker_progress_resource import EducationSpeakerProgressResource
         from .education_teams_app_resource import EducationTeamsAppResource
         from .education_word_resource import EducationWordResource
         from .identity_set import IdentitySet
@@ -120,6 +126,7 @@ class EducationResource(AdditionalDataHolder, BackedModel, Parsable):
         from .education_link_resource import EducationLinkResource
         from .education_media_resource import EducationMediaResource
         from .education_power_point_resource import EducationPowerPointResource
+        from .education_speaker_progress_resource import EducationSpeakerProgressResource
         from .education_teams_app_resource import EducationTeamsAppResource
         from .education_word_resource import EducationWordResource
         from .identity_set import IdentitySet

msgraph/generated/models/education_speaker_coach_audience_engagement_settings.py

@@ -0,0 +1,54 @@
+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 EducationSpeakerCoachAudienceEngagementSettings(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)
+    # Indicates whether the student should receive feedback on their body language from the Speaker Coach.
+    is_body_language_enabled: Optional[bool] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> EducationSpeakerCoachAudienceEngagementSettings:
+        """
+        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: EducationSpeakerCoachAudienceEngagementSettings
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return EducationSpeakerCoachAudienceEngagementSettings()
+    
+    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]] = {
+            "isBodyLanguageEnabled": lambda n : setattr(self, 'is_body_language_enabled', n.get_bool_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_bool_value("isBodyLanguageEnabled", self.is_body_language_enabled)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/education_speaker_coach_content_settings.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from kiota_abstractions.store import BackedModel, BackingStore, BackingStoreFactorySingleton
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+@dataclass
+class EducationSpeakerCoachContentSettings(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)
+    # Indicates whether the student should receive feedback on their inclusiveness from the Speaker Coach.
+    is_inclusiveness_enabled: Optional[bool] = None
+    # Indicates whether the student should receive feedback on their repetitive language from the Speaker Coach.
+    is_repetitive_language_enabled: Optional[bool] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> EducationSpeakerCoachContentSettings:
+        """
+        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: EducationSpeakerCoachContentSettings
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return EducationSpeakerCoachContentSettings()
+    
+    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]] = {
+            "isInclusivenessEnabled": lambda n : setattr(self, 'is_inclusiveness_enabled', n.get_bool_value()),
+            "isRepetitiveLanguageEnabled": lambda n : setattr(self, 'is_repetitive_language_enabled', n.get_bool_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_bool_value("isInclusivenessEnabled", self.is_inclusiveness_enabled)
+        writer.write_bool_value("isRepetitiveLanguageEnabled", self.is_repetitive_language_enabled)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/education_speaker_coach_delivery_settings.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
+
+@dataclass
+class EducationSpeakerCoachDeliverySettings(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)
+    # Indicates whether the student should receive feedback on their filler words from the Speaker Coach.
+    are_filler_words_enabled: Optional[bool] = None
+    # Indicates whether the student should receive feedback on their pace from the Speaker Coach.
+    is_pace_enabled: Optional[bool] = None
+    # Indicates whether the student should receive feedback on their pitch from the Speaker Coach.
+    is_pitch_enabled: Optional[bool] = None
+    # Indicates whether the student should receive feedback on their pronunciation from the Speaker Coach. This is automatically enabled if isAiFeedbackEnabled is set to true on the educationSpeakerProgressResource, or if spokenLanguageLocale is set to a value besides en-US on the educationSpeakerProgressResource.
+    is_pronunciation_enabled: Optional[bool] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> EducationSpeakerCoachDeliverySettings:
+        """
+        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: EducationSpeakerCoachDeliverySettings
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return EducationSpeakerCoachDeliverySettings()
+    
+    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]] = {
+            "areFillerWordsEnabled": lambda n : setattr(self, 'are_filler_words_enabled', n.get_bool_value()),
+            "isPaceEnabled": lambda n : setattr(self, 'is_pace_enabled', n.get_bool_value()),
+            "isPitchEnabled": lambda n : setattr(self, 'is_pitch_enabled', n.get_bool_value()),
+            "isPronunciationEnabled": lambda n : setattr(self, 'is_pronunciation_enabled', n.get_bool_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_bool_value("areFillerWordsEnabled", self.are_filler_words_enabled)
+        writer.write_bool_value("isPaceEnabled", self.is_pace_enabled)
+        writer.write_bool_value("isPitchEnabled", self.is_pitch_enabled)
+        writer.write_bool_value("isPronunciationEnabled", self.is_pronunciation_enabled)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/education_speaker_coach_settings.py

@@ -0,0 +1,75 @@
+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 .education_speaker_coach_audience_engagement_settings import EducationSpeakerCoachAudienceEngagementSettings
+    from .education_speaker_coach_content_settings import EducationSpeakerCoachContentSettings
+    from .education_speaker_coach_delivery_settings import EducationSpeakerCoachDeliverySettings
+
+@dataclass
+class EducationSpeakerCoachSettings(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 audience engagement related feedback types that students should receive from the Speaker Coach.
+    audience_engagement_settings: Optional[EducationSpeakerCoachAudienceEngagementSettings] = None
+    # The content related feedback types that students should receive from the Speaker Coach.
+    content_settings: Optional[EducationSpeakerCoachContentSettings] = None
+    # The delivery related feedback types that students should receive from the Speaker Coach.
+    delivery_settings: Optional[EducationSpeakerCoachDeliverySettings] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> EducationSpeakerCoachSettings:
+        """
+        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: EducationSpeakerCoachSettings
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return EducationSpeakerCoachSettings()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .education_speaker_coach_audience_engagement_settings import EducationSpeakerCoachAudienceEngagementSettings
+        from .education_speaker_coach_content_settings import EducationSpeakerCoachContentSettings
+        from .education_speaker_coach_delivery_settings import EducationSpeakerCoachDeliverySettings
+
+        from .education_speaker_coach_audience_engagement_settings import EducationSpeakerCoachAudienceEngagementSettings
+        from .education_speaker_coach_content_settings import EducationSpeakerCoachContentSettings
+        from .education_speaker_coach_delivery_settings import EducationSpeakerCoachDeliverySettings
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "audienceEngagementSettings": lambda n : setattr(self, 'audience_engagement_settings', n.get_object_value(EducationSpeakerCoachAudienceEngagementSettings)),
+            "contentSettings": lambda n : setattr(self, 'content_settings', n.get_object_value(EducationSpeakerCoachContentSettings)),
+            "deliverySettings": lambda n : setattr(self, 'delivery_settings', n.get_object_value(EducationSpeakerCoachDeliverySettings)),
+            "@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_object_value("audienceEngagementSettings", self.audience_engagement_settings)
+        writer.write_object_value("contentSettings", self.content_settings)
+        writer.write_object_value("deliverySettings", self.delivery_settings)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_additional_data_value(self.additional_data)
+    
+