msgraph-sdk 1.39.0__py3-none-any.whl → 1.44.0__py3-none-any.whl

msgraph/generated/models/sign_in_conditions.py

@@ -0,0 +1,112 @@
+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 .authentication_flow import AuthenticationFlow
+    from .conditional_access_client_app import ConditionalAccessClientApp
+    from .conditional_access_device_platform import ConditionalAccessDevicePlatform
+    from .device_info import DeviceInfo
+    from .insider_risk_level import InsiderRiskLevel
+    from .risk_level import RiskLevel
+
+@dataclass
+class SignInConditions(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)
+    # Type of authentication flow. The possible value is: deviceCodeFlow or authenticationTransfer. Default value is none.
+    authentication_flow: Optional[AuthenticationFlow] = None
+    # Client application type. The possible value is: all, browser, mobileAppsAndDesktopClients, exchangeActiveSync, easSupported, other, unknownFutureValue. Default value is all.
+    client_app_type: Optional[ConditionalAccessClientApp] = None
+    # Country from where the identity is authenticating.
+    country: Optional[str] = None
+    # Information about the device used for the sign-in.
+    device_info: Optional[DeviceInfo] = None
+    # Device platform. The possible value is: android, iOS, windows, windowsPhone, macOS, all, unknownFutureValue, linux. Default value is all.
+    device_platform: Optional[ConditionalAccessDevicePlatform] = None
+    # Insider risk associated with the authenticating user. The possible value is: none, minor, moderate, elevated, unknownFutureValue. Default value is none.
+    insider_risk_level: Optional[InsiderRiskLevel] = None
+    # Ip address of the authenticating identity.
+    ip_address: Optional[str] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # Risk associated with the service principal. The possible value is: low, medium, high, hidden, none, unknownFutureValue. Default value is none.
+    service_principal_risk_level: Optional[RiskLevel] = None
+    # Sign-in risk associated with the user. The possible value is: low, medium, high, hidden, none, unknownFutureValue. Default value is none.
+    sign_in_risk_level: Optional[RiskLevel] = None
+    # The authenticating user's risk level. The possible value is: low, medium, high, hidden, none, unknownFutureValue. Default value is none.
+    user_risk_level: Optional[RiskLevel] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SignInConditions:
+        """
+        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: SignInConditions
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SignInConditions()
+    
+    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_flow import AuthenticationFlow
+        from .conditional_access_client_app import ConditionalAccessClientApp
+        from .conditional_access_device_platform import ConditionalAccessDevicePlatform
+        from .device_info import DeviceInfo
+        from .insider_risk_level import InsiderRiskLevel
+        from .risk_level import RiskLevel
+
+        from .authentication_flow import AuthenticationFlow
+        from .conditional_access_client_app import ConditionalAccessClientApp
+        from .conditional_access_device_platform import ConditionalAccessDevicePlatform
+        from .device_info import DeviceInfo
+        from .insider_risk_level import InsiderRiskLevel
+        from .risk_level import RiskLevel
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "authenticationFlow": lambda n : setattr(self, 'authentication_flow', n.get_object_value(AuthenticationFlow)),
+            "clientAppType": lambda n : setattr(self, 'client_app_type', n.get_enum_value(ConditionalAccessClientApp)),
+            "country": lambda n : setattr(self, 'country', n.get_str_value()),
+            "deviceInfo": lambda n : setattr(self, 'device_info', n.get_object_value(DeviceInfo)),
+            "devicePlatform": lambda n : setattr(self, 'device_platform', n.get_enum_value(ConditionalAccessDevicePlatform)),
+            "insiderRiskLevel": lambda n : setattr(self, 'insider_risk_level', n.get_enum_value(InsiderRiskLevel)),
+            "ipAddress": lambda n : setattr(self, 'ip_address', n.get_str_value()),
+            "@odata.type": lambda n : setattr(self, 'odata_type', n.get_str_value()),
+            "servicePrincipalRiskLevel": lambda n : setattr(self, 'service_principal_risk_level', n.get_enum_value(RiskLevel)),
+            "signInRiskLevel": lambda n : setattr(self, 'sign_in_risk_level', n.get_enum_value(RiskLevel)),
+            "userRiskLevel": lambda n : setattr(self, 'user_risk_level', n.get_enum_value(RiskLevel)),
+        }
+        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("authenticationFlow", self.authentication_flow)
+        writer.write_enum_value("clientAppType", self.client_app_type)
+        writer.write_str_value("country", self.country)
+        writer.write_object_value("deviceInfo", self.device_info)
+        writer.write_enum_value("devicePlatform", self.device_platform)
+        writer.write_enum_value("insiderRiskLevel", self.insider_risk_level)
+        writer.write_str_value("ipAddress", self.ip_address)
+        writer.write_str_value("@odata.type", self.odata_type)
+        writer.write_enum_value("servicePrincipalRiskLevel", self.service_principal_risk_level)
+        writer.write_enum_value("signInRiskLevel", self.sign_in_risk_level)
+        writer.write_enum_value("userRiskLevel", self.user_risk_level)
+        writer.write_additional_data_value(self.additional_data)
+    
+

msgraph/generated/models/sign_in_context.py

@@ -0,0 +1,80 @@
+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 .application_context import ApplicationContext
+    from .auth_context import AuthContext
+    from .user_action_context import UserActionContext
+
+@dataclass
+class SignInContext(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) -> SignInContext:
+        """
+        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: SignInContext
+        """
+        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.applicationContext".casefold():
+            from .application_context import ApplicationContext
+
+            return ApplicationContext()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.authContext".casefold():
+            from .auth_context import AuthContext
+
+            return AuthContext()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.userActionContext".casefold():
+            from .user_action_context import UserActionContext
+
+            return UserActionContext()
+        return SignInContext()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .application_context import ApplicationContext
+        from .auth_context import AuthContext
+        from .user_action_context import UserActionContext
+
+        from .application_context import ApplicationContext
+        from .auth_context import AuthContext
+        from .user_action_context import UserActionContext
+
+        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/sign_in_identity.py

@@ -0,0 +1,73 @@
+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 .service_principal_sign_in import ServicePrincipalSignIn
+    from .user_sign_in import UserSignIn
+
+@dataclass
+class SignInIdentity(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) -> SignInIdentity:
+        """
+        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: SignInIdentity
+        """
+        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.servicePrincipalSignIn".casefold():
+            from .service_principal_sign_in import ServicePrincipalSignIn
+
+            return ServicePrincipalSignIn()
+        if mapping_value and mapping_value.casefold() == "#microsoft.graph.userSignIn".casefold():
+            from .user_sign_in import UserSignIn
+
+            return UserSignIn()
+        return SignInIdentity()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .service_principal_sign_in import ServicePrincipalSignIn
+        from .user_sign_in import UserSignIn
+
+        from .service_principal_sign_in import ServicePrincipalSignIn
+        from .user_sign_in import UserSignIn
+
+        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/single_user.py

@@ -13,7 +13,7 @@ from .subject_set import SubjectSet
 class SingleUser(SubjectSet, Parsable):
     # The OdataType property
     odata_type: Optional[str] = "#microsoft.graph.singleUser"
-    # The name of the user in Microsoft Entra ID. Read only.
+    # The name of the user in Microsoft Entra ID. Read-only.
     description: Optional[str] = None
     # The ID of the user in Microsoft Entra ID.
     user_id: Optional[str] = None

msgraph/generated/models/teams_tab.py

@@ -21,7 +21,7 @@ class TeamsTab(Entity, Parsable):
     odata_type: Optional[str] = None
     # The application that is linked to the tab. This can't be changed after tab creation.
     teams_app: Optional[TeamsApp] = None
-    # Deep link URL of the tab instance. Read only.
+    # Deep link URL of the tab instance. Read-only.
     web_url: Optional[str] = None
     
     @staticmethod

msgraph/generated/models/used_insight.py

@@ -14,13 +14,13 @@ from .entity import Entity
 
 @dataclass
 class UsedInsight(Entity, Parsable):
-    # Information about when the item was last viewed or modified by the user. Read only.
+    # Information about when the item was last viewed or modified by the user. Read-only.
     last_used: Optional[UsageDetails] = None
     # The OdataType property
     odata_type: Optional[str] = None
     # Used for navigating to the item that was used. For file attachments, the type is fileAttachment. For linked attachments, the type is driveItem.
     resource: Optional[Entity] = None
-    # Reference properties of the used document, such as the url and type of the document. Read-only
+    # Reference properties of the used document, such as the URL and type of the document. Read-only
     resource_reference: Optional[ResourceReference] = None
     # Properties that you can use to visualize the document in your experience. Read-only
     resource_visualization: Optional[ResourceVisualization] = None

msgraph/generated/models/user_action.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class UserAction(str, Enum):
+    RegisterSecurityInformation = "registerSecurityInformation",
+    RegisterOrJoinDevices = "registerOrJoinDevices",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/{security/ai_app_interaction_audit_record.py → user_action_context.py}

@@ -5,36 +5,42 @@ from kiota_abstractions.serialization import Parsable, ParseNode, SerializationW
 from typing import Any, Optional, TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
-    from .audit_data import AuditData
+    from .sign_in_context import SignInContext
+    from .user_action import UserAction
 
-from .audit_data import AuditData
+from .sign_in_context import SignInContext
 
 @dataclass
-class AiAppInteractionAuditRecord(AuditData, Parsable):
+class UserActionContext(SignInContext, Parsable):
     # The OdataType property
-    odata_type: Optional[str] = "#microsoft.graph.security.aiAppInteractionAuditRecord"
+    odata_type: Optional[str] = "#microsoft.graph.userActionContext"
+    # Represents the user action that the authenticating identity is performing. The possible values are: registerSecurityInformation, registerOrJoinDevices, unknownFutureValue.
+    user_action: Optional[UserAction] = None
     
     @staticmethod
-    def create_from_discriminator_value(parse_node: ParseNode) -> AiAppInteractionAuditRecord:
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserActionContext:
         """
         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: AiAppInteractionAuditRecord
+        Returns: UserActionContext
         """
         if parse_node is None:
             raise TypeError("parse_node cannot be null.")
-        return AiAppInteractionAuditRecord()
+        return UserActionContext()
     
     def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
         """
         The deserialization information for the current model
         Returns: dict[str, Callable[[ParseNode], None]]
         """
-        from .audit_data import AuditData
+        from .sign_in_context import SignInContext
+        from .user_action import UserAction
 
-        from .audit_data import AuditData
+        from .sign_in_context import SignInContext
+        from .user_action import UserAction
 
         fields: dict[str, Callable[[Any], None]] = {
+            "userAction": lambda n : setattr(self, 'user_action', n.get_enum_value(UserAction)),
         }
         super_fields = super().get_field_deserializers()
         fields.update(super_fields)
@@ -49,5 +55,6 @@ class AiAppInteractionAuditRecord(AuditData, Parsable):
         if writer is None:
             raise TypeError("writer cannot be null.")
         super().serialize(writer)
+        writer.write_enum_value("userAction", self.user_action)
     
 

msgraph/generated/models/user_sign_in.py

@@ -0,0 +1,68 @@
+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 .conditional_access_guest_or_external_user_types import ConditionalAccessGuestOrExternalUserTypes
+    from .sign_in_identity import SignInIdentity
+
+from .sign_in_identity import SignInIdentity
+
+@dataclass
+class UserSignIn(SignInIdentity, Parsable):
+    # The OdataType property
+    odata_type: Optional[str] = "#microsoft.graph.userSignIn"
+    # TenantId of the guest user as applies to Microsoft Entra B2B scenarios.
+    external_tenant_id: Optional[str] = None
+    # The externalUserType property
+    external_user_type: Optional[ConditionalAccessGuestOrExternalUserTypes] = None
+    # Object ID of the user.
+    user_id: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserSignIn:
+        """
+        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: UserSignIn
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserSignIn()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .conditional_access_guest_or_external_user_types import ConditionalAccessGuestOrExternalUserTypes
+        from .sign_in_identity import SignInIdentity
+
+        from .conditional_access_guest_or_external_user_types import ConditionalAccessGuestOrExternalUserTypes
+        from .sign_in_identity import SignInIdentity
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "externalTenantId": lambda n : setattr(self, 'external_tenant_id', n.get_str_value()),
+            "externalUserType": lambda n : setattr(self, 'external_user_type', n.get_collection_of_enum_values(ConditionalAccessGuestOrExternalUserTypes)),
+            "userId": lambda n : setattr(self, 'user_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("externalTenantId", self.external_tenant_id)
+        writer.write_enum_value("externalUserType", self.external_user_type)
+        writer.write_str_value("userId", self.user_id)
+    
+

msgraph/generated/models/what_if_analysis_reasons.py

@@ -0,0 +1,25 @@
+from enum import Enum
+
+class WhatIfAnalysisReasons(str, Enum):
+    NotSet = "notSet",
+    NotEnoughInformation = "notEnoughInformation",
+    InvalidCondition = "invalidCondition",
+    Users = "users",
+    WorkloadIdentities = "workloadIdentities",
+    Application = "application",
+    UserActions = "userActions",
+    AuthenticationContext = "authenticationContext",
+    DevicePlatform = "devicePlatform",
+    Devices = "devices",
+    ClientApps = "clientApps",
+    Location = "location",
+    SignInRisk = "signInRisk",
+    EmptyPolicy = "emptyPolicy",
+    InvalidPolicy = "invalidPolicy",
+    PolicyNotEnabled = "policyNotEnabled",
+    UserRisk = "userRisk",
+    Time = "time",
+    InsiderRisk = "insiderRisk",
+    AuthenticationFlow = "authenticationFlow",
+    UnknownFutureValue = "unknownFutureValue",
+

msgraph/generated/models/what_if_analysis_result.py

@@ -0,0 +1,64 @@
+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 .conditional_access_policy import ConditionalAccessPolicy
+    from .what_if_analysis_reasons import WhatIfAnalysisReasons
+
+from .conditional_access_policy import ConditionalAccessPolicy
+
+@dataclass
+class WhatIfAnalysisResult(ConditionalAccessPolicy, Parsable):
+    # The analysisReasons property
+    analysis_reasons: Optional[WhatIfAnalysisReasons] = None
+    # The OdataType property
+    odata_type: Optional[str] = None
+    # Specifies whether the policy applies to the sign-in properties provided in the request body. If policyApplies is true, the policy applies to the sign-in based on the sign-in properties provided. If policyApplies is false, the policy doesn't apply to the sign-in based on the sign-in properties provided and the analysisReasons property is populated to show the reason for the policy not applying.
+    policy_applies: Optional[bool] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> WhatIfAnalysisResult:
+        """
+        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: WhatIfAnalysisResult
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return WhatIfAnalysisResult()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .conditional_access_policy import ConditionalAccessPolicy
+        from .what_if_analysis_reasons import WhatIfAnalysisReasons
+
+        from .conditional_access_policy import ConditionalAccessPolicy
+        from .what_if_analysis_reasons import WhatIfAnalysisReasons
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "analysisReasons": lambda n : setattr(self, 'analysis_reasons', n.get_collection_of_enum_values(WhatIfAnalysisReasons)),
+            "policyApplies": lambda n : setattr(self, 'policy_applies', n.get_bool_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_enum_value("analysisReasons", self.analysis_reasons)
+        writer.write_bool_value("policyApplies", self.policy_applies)
+    
+

msgraph/generated/models/win32_lob_app.py

@@ -21,6 +21,8 @@ class Win32LobApp(MobileLobApp, Parsable):
     """
     # The OdataType property
     odata_type: Optional[str] = "#microsoft.graph.win32LobApp"
+    # Indicates the Windows architecture(s) this app should be installed on. The app will be treated as not applicable for devices with architectures not matching the selected value. When a non-null value is provided for the `allowedArchitectures` property, the value of the `applicableArchitectures` property is set to `none`. Possible values are: `null`, `x86`, `x64`, `arm64`.
+    allowed_architectures: Optional[WindowsArchitecture] = None
     # Contains properties for Windows architecture.
     applicable_architectures: Optional[WindowsArchitecture] = None
     # The command line to install this app
@@ -79,6 +81,7 @@ class Win32LobApp(MobileLobApp, Parsable):
         from .windows_architecture import WindowsArchitecture
 
         fields: dict[str, Callable[[Any], None]] = {
+            "allowedArchitectures": lambda n : setattr(self, 'allowed_architectures', n.get_collection_of_enum_values(WindowsArchitecture)),
             "applicableArchitectures": lambda n : setattr(self, 'applicable_architectures', n.get_collection_of_enum_values(WindowsArchitecture)),
             "installCommandLine": lambda n : setattr(self, 'install_command_line', n.get_str_value()),
             "installExperience": lambda n : setattr(self, 'install_experience', n.get_object_value(Win32LobAppInstallExperience)),
@@ -106,6 +109,7 @@ class Win32LobApp(MobileLobApp, Parsable):
         if writer is None:
             raise TypeError("writer cannot be null.")
         super().serialize(writer)
+        writer.write_enum_value("allowedArchitectures", self.allowed_architectures)
         writer.write_enum_value("applicableArchitectures", self.applicable_architectures)
         writer.write_str_value("installCommandLine", self.install_command_line)
         writer.write_object_value("installExperience", self.install_experience)

msgraph/generated/models/windows_defender_product_status.py

@@ -11,11 +11,11 @@ class WindowsDefenderProductStatus(str, Enum):
     PendingFullScanDueToThreatAction = "pendingFullScanDueToThreatAction",
     # Pending reboot due to threat action
     PendingRebootDueToThreatAction = "pendingRebootDueToThreatAction",
-    # Pending manual steps due to threat action 
+    # Pending manual steps due to threat action
     PendingManualStepsDueToThreatAction = "pendingManualStepsDueToThreatAction",
-    # AV signatures out of date
+    # Antivirus (AV) signatures out of date
     AvSignaturesOutOfDate = "avSignaturesOutOfDate",
-    # AS signatures out of date
+    # Antisypware (AS) signatures out of date
     AsSignaturesOutOfDate = "asSignaturesOutOfDate",
     # No quick scan has happened for a specified period
     NoQuickScanHappenedForSpecifiedPeriod = "noQuickScanHappenedForSpecifiedPeriod",

msgraph/generated/models/windows_update_for_business_update_weeks.py

@@ -13,6 +13,6 @@ class WindowsUpdateForBusinessUpdateWeeks(str, Enum):
     FourthWeek = "fourthWeek",
     # Scheduled the update installation on every week of the month
     EveryWeek = "everyWeek",
-    # Evolvable enum member
+    # Evolvable enumeration sentinel value. Do not use.
     UnknownFutureValue = "unknownFutureValue",
 

msgraph/generated/models/windows_update_notification_display_option.py

@@ -9,6 +9,6 @@ class WindowsUpdateNotificationDisplayOption(str, Enum):
     RestartWarningsOnly = "restartWarningsOnly",
     # Turn off all notifications, including restart warnings.
     DisableAllNotifications = "disableAllNotifications",
-    # Evolvable enum member
+    # Evolvable enumeration sentinel value. Do not use.
     UnknownFutureValue = "unknownFutureValue",
 

msgraph/generated/models/workbook_worksheet_protection_options.py

@@ -12,27 +12,27 @@ class WorkbookWorksheetProtectionOptions(AdditionalDataHolder, BackedModel, Pars
 
     # 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 worksheet protection option to allow the use of the autofilter feature is enabled.
+    # Represents the worksheet protection option of allowing using auto filter feature.
     allow_auto_filter: Optional[bool] = None
-    # Indicates whether the worksheet protection option to allow deleting columns is enabled.
+    # Represents the worksheet protection option of allowing deleting columns.
     allow_delete_columns: Optional[bool] = None
-    # Indicates whether the worksheet protection option to allow deleting rows is enabled.
+    # Represents the worksheet protection option of allowing deleting rows.
     allow_delete_rows: Optional[bool] = None
-    # Indicates whether the worksheet protection option to allow formatting cells is enabled.
+    # Represents the worksheet protection option of allowing formatting cells.
     allow_format_cells: Optional[bool] = None
-    # Indicates whether the worksheet protection option to allow formatting columns is enabled.
+    # Represents the worksheet protection option of allowing formatting columns.
     allow_format_columns: Optional[bool] = None
-    # Indicates whether the worksheet protection option to allow formatting rows is enabled.
+    # Represents the worksheet protection option of allowing formatting rows.
     allow_format_rows: Optional[bool] = None
-    # Indicates whether the worksheet protection option to allow inserting columns is enabled.
+    # Represents the worksheet protection option of allowing inserting columns.
     allow_insert_columns: Optional[bool] = None
-    # Indicates whether the worksheet protection option to allow inserting hyperlinks is enabled.
+    # Represents the worksheet protection option of allowing inserting hyperlinks.
     allow_insert_hyperlinks: Optional[bool] = None
-    # Indicates whether the worksheet protection option to allow inserting rows is enabled.
+    # Represents the worksheet protection option of allowing inserting rows.
     allow_insert_rows: Optional[bool] = None
-    # Indicates whether the worksheet protection option to allow the use of the pivot table feature is enabled.
+    # Represents the worksheet protection option of allowing using pivot table feature.
     allow_pivot_tables: Optional[bool] = None
-    # Indicates whether the worksheet protection option to allow the use of the sort feature is enabled.
+    # Represents the worksheet protection option of allowing using sort feature.
     allow_sort: Optional[bool] = None
     # The OdataType property
     odata_type: Optional[str] = None