Office365-REST-Python-Client 2.4.2__py3-none-any.whl → 2.4.4__py3-none-any.whl

office365/directory/groups/group.py

@@ -1,6 +1,7 @@
 import json
+from datetime import datetime
 
-from office365.directory.applications.roles.assignment import AppRoleAssignmentCollection
+from office365.directory.applications.roles.assignment_collection import AppRoleAssignmentCollection
 from office365.directory.extensions.extension import Extension
 from office365.directory.licenses.assigned_license import AssignedLicense
 from office365.directory.object import DirectoryObject
@@ -39,8 +40,9 @@ class Group(DirectoryObject):
         return self
 
     def check_granted_permissions_for_app(self):
+        """"""
         return_type = EntityCollection(self.context, ResourceSpecificPermissionGrant)
-        qry = ServiceOperationQuery(self, "checkGrantedPermissionsForApp", None, None, None, return_type)
+        qry = ServiceOperationQuery(self, "checkGrantedPermissionsForApp", return_type=return_type)
         self.context.add_query(qry)
         return return_type
 
@@ -87,8 +89,7 @@ class Group(DirectoryObject):
             request.set_header('Content-Type', "application/json")
             request.data = json.dumps(request.data)
 
-        self.context.add_query(qry)
-        self.context.before_query_execute(_construct_request)
+        self.context.add_query(qry).before_query_execute(_construct_request, once=False)
         return self.team
 
     def delete_object(self, permanent_delete=False):
@@ -103,6 +104,13 @@ class Group(DirectoryObject):
             deleted_item.delete_object()
         return self
 
+    @property
+    def display_name(self):
+        """
+        :rtype: str
+        """
+        return self.properties.get("displayName", None)
+
     @property
     def conversations(self):
         """The group's conversations."""
@@ -110,6 +118,11 @@ class Group(DirectoryObject):
                                    EntityCollection(self.context, Conversation,
                                                     ResourcePath("conversations", self.resource_path)))
 
+    @property
+    def created_datetime(self):
+        """Timestamp of when the group was created."""
+        return self.properties.get('createdDateTime', datetime.min)
+
     @property
     def extensions(self):
         """
@@ -217,6 +230,7 @@ class Group(DirectoryObject):
             property_mapping = {
                 "appRoleAssignments": self.app_role_assignments,
                 "assignedLicenses": self.assigned_licenses,
+                "createdDateTime": self.created_datetime,
                 "transitiveMembers": self.transitive_members,
                 "transitiveMemberOf": self.transitive_member_of,
             }

office365/directory/identities/governance.py

@@ -11,3 +11,5 @@ class IdentityGovernance(Entity):
        - App consent
        - Terms of use
     """
+
+

office365/directory/identities/object_identity.py

@@ -6,10 +6,10 @@ class ObjectIdentity(ClientValue):
     Represents an identity used to sign in to a user account.
     """
 
-    def __init__(self, signInType=None, issuer=None, issuer_assigned_id=None):
+    def __init__(self, sign_in_type=None, issuer=None, issuer_assigned_id=None):
         """
 
-        :param str signInType: Specifies the user sign-in types in your directory, such as emailAddress, userName
+        :param str sign_in_type: Specifies the user sign-in types in your directory, such as emailAddress, userName
             or federated. Here, federated represents a unique identifier for a user from an issuer, that can be in
             any format chosen by the issuer. Additional validation is enforced on issuerAssignedId when the sign-in
             type is set to emailAddress or userName. This property can also be set to any custom string.
@@ -24,6 +24,6 @@ class ObjectIdentity(ClientValue):
             (also known as local accounts).
         """
         super(ObjectIdentity, self).__init__()
-        self.signInType = signInType
+        self.signInType = sign_in_type
         self.issuer = issuer
         self.issuerAssignedId = issuer_assigned_id

office365/directory/insights/resource_reference.py

@@ -0,0 +1,15 @@
+from office365.runtime.client_value import ClientValue
+
+
+class ResourceReference(ClientValue):
+    """Complex type containing properties of officeGraphInsights."""
+
+    def __init__(self, _id=None, _type=None, web_url=None):
+        """
+        :param str _id: The item's unique identifier.
+        :param str _type:A string value that can be used to classify the item, such as "microsoft.graph.driveItem"
+        :param str web_url: A URL leading to the referenced item.
+        """
+        self.id = _id
+        self.type = _type
+        self.webUrl = web_url

office365/directory/insights/shared.py

@@ -1,4 +1,8 @@
+from office365.directory.insights.resource_reference import ResourceReference
+from office365.directory.insights.sharing_detail import SharingDetail
 from office365.entity import Entity
+from office365.runtime.client_value_collection import ClientValueCollection
+from office365.runtime.paths.resource_path import ResourcePath
 
 
 class SharedInsight(Entity):
@@ -9,3 +13,35 @@ class SharedInsight(Entity):
       OneDrive for Business and SharePoint modern attachments - files stored in OneDrive for Business and SharePoint
       that users share as a links in an email.
     """
+
+    @property
+    def last_shared(self):
+        """Details about the shared item. Read-only"""
+        return self.properties.get("lastShared", SharingDetail())
+
+    @property
+    def resource_reference(self):
+        """Reference properties of the used document, such as the url and type of the document. Read-only"""
+        return self.properties.get("resourceReference", ResourceReference())
+
+    @property
+    def resource(self):
+        """Used for navigating to the item that was shared. For file attachments, the type is fileAttachment.
+        For linked attachments, the type is driveItem."""
+        return self.properties.get('resource',
+                                   Entity(self.context, ResourcePath("resource", self.resource_path)))
+
+    @property
+    def sharing_history(self):
+        """Details about the sharing history. Read-only"""
+        return self.properties.get("sharingHistory", ClientValueCollection(SharingDetail))
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "lastShared": self.last_shared,
+                "resourceReference": self.resource_reference,
+                "sharingHistory": self.sharing_history
+            }
+            default_value = property_mapping.get(name, None)
+        return super(SharedInsight, self).get_property(name, default_value)

office365/directory/insights/sharing_detail.py

@@ -0,0 +1,11 @@
+from office365.runtime.client_value import ClientValue
+
+
+class SharingDetail(ClientValue):
+    """Complex type containing properties of sharedInsight items."""
+
+    def __init__(self, shared_datetime=None):
+        """
+        :param datetime.datetime shared_datetime: The date and time the file was last shared.
+        """
+        self.sharedDateTime = shared_datetime

office365/directory/insights/trending.py

@@ -1,4 +1,5 @@
 from office365.entity import Entity
+from office365.runtime.paths.resource_path import ResourcePath
 
 
 class Trending(Entity):
@@ -6,3 +7,10 @@ class Trending(Entity):
     Rich relationship connecting a user to documents that are trending around the user (are relevant to the user).
     OneDrive files, and files stored on SharePoint team sites can trend around the user.
     """
+
+    @property
+    def resource(self):
+        """Used for navigating to the trending document."""
+        return self.properties.get('resource',
+                                   Entity(self.context, ResourcePath("resource", self.resource_path)))
+

office365/directory/insights/usage_details.py

@@ -0,0 +1,16 @@
+from datetime import datetime
+
+from office365.runtime.client_value import ClientValue
+
+
+class UsageDetails(ClientValue):
+    """Complex type containing properties of Used items. Information on when the resource was last accessed (viewed)
+    or modified (edited) by the user."""
+
+    def __init__(self, last_accessed_datetime=None, last_modified_datetime=None):
+        """
+        :param datetime.datetime last_accessed_datetime: The date and time the resource was last accessed by the user.
+        :param datetime.datetime last_modified_datetime: The date and time the resource was last modified by the user.
+        """
+        self.lastAccessedDateTime = last_accessed_datetime
+        self.lastModifiedDateTime = last_modified_datetime

office365/directory/insights/used.py

@@ -1,4 +1,7 @@
+from office365.directory.insights.resource_reference import ResourceReference
+from office365.directory.insights.usage_details import UsageDetails
 from office365.entity import Entity
+from office365.runtime.paths.resource_path import ResourcePath
 
 
 class UsedInsight(Entity):
@@ -8,3 +11,30 @@ class UsedInsight(Entity):
       OneDrive for Business
       SharePoint
     """
+
+    @property
+    def last_used(self):
+        """Information about when the item was last viewed or modified by the user."""
+        return self.properties.get("lastUsed", UsageDetails())
+
+    @property
+    def resource_reference(self):
+        """Reference properties of the used document, such as the url and type of the document. Read-only"""
+        return self.properties.get("resourceReference", ResourceReference())
+
+    @property
+    def resource(self):
+        """Used for navigating to the item that was used. For file attachments, the type is fileAttachment.
+        For linked attachments, the type is driveItem."""
+        return self.properties.get('resource',
+                                   Entity(self.context, ResourcePath("resource", self.resource_path)))
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "lastUsed": self.last_used,
+                "resourceReference": self.resource_reference
+            }
+            default_value = property_mapping.get(name, None)
+        return super(UsedInsight, self).get_property(name, default_value)
+

office365/directory/invitations/invitation.py

@@ -5,7 +5,39 @@ from office365.runtime.paths.resource_path import ResourcePath
 
 
 class Invitation(Entity):
-    """Represents an invitation that is used to add external users to an organization."""
+    """Represents an invitation that is used to add external users to an organization.
+
+    The invitation process uses the following flow:
+
+      - An invitation is created
+      - An invitation is sent to the invited user (containing an invitation link)
+      - The invited user clicks on the invitation link, signs in and redeems the invitation and creation of the
+        user entity representing the invited user completes
+      - The user is redirected to a specific page after redemption completes
+
+     Creating an invitation will return a redemption URL in the response (inviteRedeemUrl).
+     The create invitation API can automatically send an email containing the redemption URL to the invited user,
+     by setting the sendInvitationMessage to true. You can also customize the message that will be sent to
+     the invited user. Instead, if you wish to send the redemption URL through some other means, you can set the
+     sendInvitationMessage to false and use the redeem URL from the response to craft your own communication.
+     Currently, there is no API to perform the redemption process. The invited user has to click on the inviteRedeemUrl
+     link sent in the communication in the step above, and go through the interactive redemption process in a browser.
+     Once completed, the invited user becomes an external user in the organization.
+    """
+
+    @property
+    def invited_user_display_name(self):
+        """The display name of the user being invited.
+        :rtype: str
+        """
+        return self.properties.get("invitedUserDisplayName", None)
+
+    @property
+    def invited_user_email_address(self):
+        """The email address of the user being invited.
+        :rtype: str
+        """
+        return self.properties.get("invitedUserEmailAddress", None)
 
     @property
     def invited_user_message_info(self):

office365/directory/licenses/assigned_plan.py

@@ -5,4 +5,22 @@ class AssignedPlan(ClientValue):
     """
     The assignedPlans property of both the user entity and the organization entity is a collection of assignedPlan.
     """
-    pass
+
+    def __init__(self, assigned_datetime=None, capability_status=None, service=None, service_plan_id=None):
+        """
+        :param datetime.datetime assigned_datetime: The date and time at which the plan was assigned.
+        :param str capability_status: Condition of the capability assignment.
+            The possible values are Enabled, Warning, Suspended, Deleted, LockedOut.
+            See a detailed description of each value.
+        :param str service: The name of the service; for example, exchange.
+        :param str service_plan_id: A GUID that identifies the service plan. For a complete list of GUIDs and their
+            equivalent friendly service names, see Product names and service plan identifiers for licensing.
+        """
+        self.assignedDateTime = assigned_datetime
+        self.capabilityStatus = capability_status
+        self.service = service
+        self.servicePlanId = service_plan_id
+
+    def __repr__(self):
+        return self.service
+

office365/directory/licenses/assignment_state.py

@@ -11,3 +11,8 @@ class LicenseAssignmentState(ClientValue):
         - The current state of the assignment
         - Error details if the assignment state is Error
     """
+    def __init__(self, assigned_by_group=None):
+        """
+        :param str assigned_by_group:
+        """
+        self.assignedByGroup = assigned_by_group

office365/directory/licenses/service_plan_info.py

@@ -27,3 +27,7 @@ class ServicePlanInfo(ClientValue):
         self.servicePlanName = name
         self.provisioningStatus = provisioning_status
         self.appliesTo = applies_to
+
+    def __repr__(self):
+        return self.servicePlanName
+

office365/directory/licenses/subscribed_sku.py

@@ -1,4 +1,5 @@
 from office365.directory.licenses.service_plan_info import ServicePlanInfo
+from office365.directory.licenses.units_detail import LicenseUnitsDetail
 from office365.entity import Entity
 from office365.runtime.client_value_collection import ClientValueCollection
 
@@ -6,6 +7,45 @@ from office365.runtime.client_value_collection import ClientValueCollection
 class SubscribedSku(Entity):
     """Contains information about a service SKU that a company is subscribed to."""
 
+    @property
+    def account_id(self):
+        """
+        The unique ID of the account this SKU belongs to.
+        :rtype: str
+        """
+        return self.properties.get("accountId", None)
+
+    @property
+    def applies_to(self):
+        """
+        The target class for this SKU. Only SKUs with target class User are assignable.
+        Possible values are: "User", "Company".
+        :rtype: str
+        """
+        return self.properties.get("appliesTo", None)
+
+    @property
+    def sku_id(self):
+        """
+        The unique identifier (GUID) for the service SKU.
+        :rtype: str
+        """
+        return self.properties.get("skuId", None)
+
+    @property
+    def sku_part_number(self):
+        """
+        The SKU part number; for example: "AAD_PREMIUM" or "RMSBASIC".
+        To get a list of commercial subscriptions that an organization has acquired, see List subscribedSkus.
+        :rtype: str
+        """
+        return self.properties.get("skuPartNumber", None)
+
+    @property
+    def prepaid_units(self):
+        """Information about the number and status of prepaid licenses."""
+        return self.properties.get("prepaidUnits", LicenseUnitsDetail())
+
     @property
     def service_plans(self):
         """Information about the service plans that are available with the SKU. Not nullable"""
@@ -14,6 +54,7 @@ class SubscribedSku(Entity):
     def get_property(self, name, default_value=None):
         if default_value is None:
             property_mapping = {
+                "prepaidUnits": self.prepaid_units,
                 "servicePlans": self.service_plans
             }
             default_value = property_mapping.get(name, None)

office365/directory/licenses/units_detail.py

@@ -0,0 +1,11 @@
+from office365.runtime.client_value import ClientValue
+
+
+class LicenseUnitsDetail(ClientValue):
+    """"""
+
+    def __init__(self, enabled=None):
+        """
+        :param int enabled: The number of units that are enabled for the active subscription of the service SKU.
+        """
+        self.enabled = enabled

office365/directory/object.py

@@ -1,3 +1,5 @@
+from datetime import datetime
+
 from office365.entity import Entity
 from office365.runtime.client_result import ClientResult
 from office365.runtime.queries.service_operation import ServiceOperationQuery
@@ -85,4 +87,4 @@ class DirectoryObject(Entity):
     @property
     def deleted_datetime(self):
         """Date and time when this object was deleted. Always null when the object hasn't been deleted."""
-        return self.properties.get('deletedDateTime', None)
+        return self.properties.get('deletedDateTime', datetime.min)

office365/directory/object_collection.py

@@ -57,18 +57,17 @@ class DirectoryObjectCollection(DeltaCollection):
     def remove(self, user_id):
         """Remove a user from the group.
 
-        :type user_id: str
+        :param str user_id: User identifier
         """
 
         qry = ServiceOperationQuery(self, "{0}/$ref".format(user_id))
-        self.context.add_query(qry)
 
-        def _construct_remove_user_request(request):
+        def _construct_request(request):
             """
             :type request: RequestOptions
             """
             request.method = HttpMethod.Delete
-        self.context.before_execute(_construct_remove_user_request)
+        self.context.add_query(qry).before_query_execute(_construct_request)
         return self
 
     def validate_properties(self, entity_type=None, display_name=None, mail_nickname=None, on_behalf_of_userid=None):

office365/directory/password_credential.py

@@ -5,15 +5,19 @@ class PasswordCredential(ClientValue):
     """Represents a password credential associated with an application or a service principal.
     The passwordCredentials property of the application entity is a collection of passwordCredential objects."""
 
-    def __init__(self, display_name=None, secret_text=None, key_id=None):
+    def __init__(self, display_name=None, secret_text=None, key_id=None, start_datetime=None):
         """
         :param str display_name: Friendly name for the password. Optional.
         :param str secret_text: Read-only; Contains the strong passwords generated by Azure AD that are 16-64
             characters in length. The generated password value is only returned during the initial POST request to
             addPassword. There is no way to retrieve this password in the future.
         :param str key_id: The unique identifier for the password.
+        :param str start_datetime: The date and time at which the password becomes valid. The Timestamp 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. Optional.
         """
         super(PasswordCredential, self).__init__()
         self.displayName = display_name
         self.secretText = secret_text
         self.keyId = key_id
+        self.startDateTime = start_datetime

office365/directory/permissions/email_identity.py

@@ -0,0 +1,5 @@
+from office365.directory.permissions.identity import Identity
+
+
+class EmailIdentity(Identity):
+    """Represents the email identity of a user."""

office365/directory/permissions/grants/condition_set.py

@@ -19,6 +19,23 @@ class PermissionGrantConditionSet(Entity):
         """
         return self.properties.get("clientApplicationIds", StringCollection())
 
+    @property
+    def client_application_publisher_ids(self):
+        """
+        A list of Microsoft Partner Network (MPN) IDs for verified publishers of the client application,  or a list
+        with the single value all to match with client apps from any publisher. Default is the single value all.
+        """
+        return self.properties.get("clientApplicationPublisherIds", StringCollection())
+
+    @property
+    def client_applications_from_verified_publisher_only(self):
+        """
+        Set to true to only match on client applications with a verified publisher. Set to false to match on any client
+        app, even if it does not have a verified publisher. Default is false.
+        :rtype: bool
+        """
+        return self.properties.get("clientApplicationsFromVerifiedPublisherOnly", None)
+
     @property
     def permissions(self):
         """
@@ -30,3 +47,12 @@ class PermissionGrantConditionSet(Entity):
         Default is the single value all.
         """
         return self.properties.get("permissions", StringCollection())
+
+    @property
+    def resource_application(self):
+        """
+        The appId of the resource application (e.g. the API) for which a permission is being granted, or any to match
+        with any resource application or API. Default is any.
+        :rtype: str
+        """
+        return self.properties.get("resourceApplication", None)

office365/directory/permissions/grants/resource_specific.py

@@ -17,3 +17,24 @@ class ResourceSpecificPermissionGrant(DirectoryObject):
         """ID of the service principal of the Azure AD app that has been granted access."""
         return self.properties.get("clientAppId", None)
 
+    @property
+    def permission(self):
+        """The name of the resource-specific permission.
+        :rtype: str
+        """
+        return self.properties.get("permission", None)
+
+    @property
+    def permission_type(self):
+        """The type of permission. Possible values are: Application, Delegated. Read-only.
+        :rtype: str
+        """
+        return self.properties.get("permissionType", None)
+
+    @property
+    def resource_app_id(self):
+        """ID of the Azure AD app that is hosting the resource. Read-only.
+        :rtype: str
+        """
+        return self.properties.get("resourceAppId", None)
+

office365/directory/policies/authentication_flows.py

@@ -0,0 +1,9 @@
+from office365.entity import Entity
+
+
+class AuthenticationFlowsPolicy(Entity):
+    """
+    Represents the policy configuration of self-service sign-up experience at a tenant level that lets external
+    users request to sign up for approval. It contains information, such as the identifier, display name, and
+    description, and indicates whether self-service sign-up is enabled for the policy.
+    """

office365/directory/policies/authentication_strength.py

@@ -0,0 +1,10 @@
+from office365.entity import Entity
+
+
+class AuthenticationStrengthPolicy(Entity):
+    """
+    A collection of settings that define specific combinations of authentication methods and metadata.
+    The authentication strength policy, when applied to a given scenario using Azure AD Conditional Access,
+    defines which authentication methods must be used to authenticate in that scenario. An authentication strength
+    may be built-in or custom (defined by the tenant) and may or may not fulfill the requirements to grant an MFA claim.
+    """

office365/directory/policies/authorization.py

@@ -4,3 +4,11 @@ from office365.directory.policies.base import PolicyBase
 class AuthorizationPolicy(PolicyBase):
     """Represents a policy that can control Azure Active Directory authorization settings.
     It's a singleton that inherits from base policy type, and always exists for the tenant."""
+
+    @property
+    def allowed_to_sign_up_email_based_subscriptions(self):
+        """
+        Indicates whether a user can join the tenant by email validation.
+        :rtype: bool
+        """
+        return self.properties.get("allowedToSignUpEmailBasedSubscriptions", None)

office365/directory/policies/cross_tenant_access.py

@@ -0,0 +1,5 @@
+from office365.directory.policies.base import PolicyBase
+
+
+class CrossTenantAccessPolicy(PolicyBase):
+    """Represents the base policy in the directory for cross-tenant access settings."""

office365/directory/policies/root.py

@@ -1,4 +1,8 @@
+from office365.directory.policies.app_management import AppManagementPolicy
+from office365.directory.policies.authentication_flows import AuthenticationFlowsPolicy
 from office365.directory.policies.authentication_methods import AuthenticationMethodsPolicy
+from office365.directory.policies.authentication_strength import AuthenticationStrengthPolicy
+from office365.directory.policies.cross_tenant_access import CrossTenantAccessPolicy
 from office365.directory.policies.permission_grant import PermissionGrantPolicy
 from office365.directory.policies.authorization import AuthorizationPolicy
 from office365.directory.policies.conditional_access import ConditionalAccessPolicy
@@ -21,6 +25,22 @@ class PolicyRoot(Entity):
                                                                ResourcePath("authenticationMethodsPolicy",
                                                                             self.resource_path)))
 
+    def authentication_strength_policies(self):
+        """
+        The authentication method combinations that are to be used in scenarios defined by Azure AD Conditional Access.
+        """
+        return self.properties.get('authenticationStrengthPolicies',
+                                   EntityCollection(self.context, AuthenticationStrengthPolicy,
+                                                    ResourcePath("authenticationStrengthPolicies", self.resource_path)))
+
+    @property
+    def authentication_flows_policy(self):
+        """	The policy configuration of the self-service sign-up experience of external users."""
+        return self.properties.get('authenticationFlowsPolicy',
+                                   AuthenticationFlowsPolicy(self.context,
+                                                             ResourcePath("authenticationFlowsPolicy",
+                                                                          self.resource_path)))
+
     @property
     def authorization_policy(self):
         """The policy that controls Azure AD authorization settings."""
@@ -33,8 +53,18 @@ class PolicyRoot(Entity):
         """The policies that enforce app management restrictions for specific applications and service principals,
         overriding the defaultAppManagementPolicy."""
         return self.properties.get('appManagementPolicies',
-                                   AuthorizationPolicy(self.context,
-                                                       ResourcePath("appManagementPolicies", self.resource_path)))
+                                   EntityCollection(self.context, AppManagementPolicy,
+                                                    ResourcePath("appManagementPolicies", self.resource_path)))
+
+    @property
+    def cross_tenant_access_policy(self):
+        """
+        The custom rules that define an access scenario when interacting with external Azure AD tenants.
+        """
+        return self.properties.get('crossTenantAccessPolicy',
+                                   CrossTenantAccessPolicy(self.context,
+                                                           ResourcePath("crossTenantAccessPolicy",
+                                                                        self.resource_path)))
 
     @property
     def permission_grant_policies(self):
@@ -57,10 +87,13 @@ class PolicyRoot(Entity):
     def get_property(self, name, default_value=None):
         if default_value is None:
             property_mapping = {
+                "authenticationStrengthPolicies": self.authentication_strength_policies,
+                "authenticationFlowsPolicy": self.authentication_flows_policy,
                 "appManagementPolicies": self.app_management_policies,
                 "authenticationMethodsPolicy": self.authentication_methods_policy,
                 "authorizationPolicy": self.authorization_policy,
                 "conditional_access_policies": self.conditional_access_policies,
+                "crossTenantAccessPolicy": self.cross_tenant_access_policy,
                 "permissionGrantPolicies": self.permission_grant_policies,
             }
             default_value = property_mapping.get(name, None)

office365/directory/protection/information.py

@@ -0,0 +1,5 @@
+from office365.entity import Entity
+
+
+class InformationProtection(Entity):
+    """Exposes methods that you can use to get Microsoft Purview Information Protection labels and label policies."""

office365/directory/protection/risk_detection.py

@@ -0,0 +1,11 @@
+from office365.entity import Entity
+
+
+class RiskDetection(Entity):
+    """
+    Represents information about a detected risk in an Azure AD tenant.
+
+    Azure AD continually evaluates user risks and app or user sign-in risks based on various signals
+    and machine learning.
+    This API provides programmatic access to all risk detections in your Azure AD environment.
+    """