/**@class android.os.UserManager
@extends java.lang.Object

 Manages users and user details on a multi-user system. There are two major categories of
 users: fully customizable users with their own login, and managed profiles that share a workspace
 with a related user.
 <p>
 Users are different from accounts, which are managed by
 {@link AccountManager}. Each user can have their own set of accounts.
 <p>
 See {@link DevicePolicyManager#ACTION_PROVISION_MANAGED_PROFILE} for more on managed profiles.
*/
var UserManager = {

/** @hide
 No user restriction.
*/
RESTRICTION_NOT_SET : "0",
/** @hide
 User restriction set by system/user.
*/
RESTRICTION_SOURCE_SYSTEM : "1",
/** @hide
 User restriction set by a device owner.
*/
RESTRICTION_SOURCE_DEVICE_OWNER : "2",
/** @hide
 User restriction set by a profile owner.
*/
RESTRICTION_SOURCE_PROFILE_OWNER : "4",
/** Specifies if a user is disallowed from adding and removing accounts, unless they are
 {@link android.accounts.AccountManager#addAccountExplicitly programmatically} added by
 Authenticator.
 The default value is <code>false</code>.

 <p>From {@link android.os.Build.VERSION_CODES#N} a profile or device owner app can still
 use {@link android.accounts.AccountManager} APIs to add or remove accounts when account
 management is disallowed.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_MODIFY_ACCOUNTS : "no_modify_accounts",
/** Specifies if a user is disallowed from changing Wi-Fi
 access points. The default value is <code>false</code>.
 <p>This restriction has no effect in a managed profile.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_CONFIG_WIFI : "no_config_wifi",
/** Specifies if a user is disallowed from changing the device
 language. The default value is <code>false</code>.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_CONFIG_LOCALE : "no_config_locale",
/** Specifies if a user is disallowed from installing applications. This user restriction also
 prevents device owners and profile owners installing apps. The default value is
 {@code false}.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_INSTALL_APPS : "no_install_apps",
/** Specifies if a user is disallowed from uninstalling applications.
 The default value is <code>false</code>.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_UNINSTALL_APPS : "no_uninstall_apps",
/** Specifies if a user is disallowed from turning on location sharing.
 The default value is <code>false</code>.
 <p>In a managed profile, location sharing always reflects the primary user's setting, but
 can be overridden and forced off by setting this restriction to true in the managed profile.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_SHARE_LOCATION : "no_share_location",
/** Specifies if airplane mode is disallowed on the device.

 <p> This restriction can only be set by the device owner and the profile owner on the
 primary user and it applies globally - i.e. it disables airplane mode on the entire device.
 <p>The default value is <code>false</code>.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_AIRPLANE_MODE : "no_airplane_mode",
/** Specifies if a user is disallowed from configuring brightness. When device owner sets it,
 it'll only be applied on the target(system) user.

 <p>The default value is <code>false</code>.

 <p>This user restriction has no effect on managed profiles.
 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_CONFIG_BRIGHTNESS : "no_config_brightness",
/** Specifies if ambient display is disallowed for the user.

 <p>The default value is <code>false</code>.

 <p>This user restriction has no effect on managed profiles.
 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_AMBIENT_DISPLAY : "no_ambient_display",
/** Specifies if a user is disallowed from changing screen off timeout.

 <p>The default value is <code>false</code>.

 <p>This user restriction has no effect on managed profiles.
 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_CONFIG_SCREEN_TIMEOUT : "no_config_screen_timeout",
/** Specifies if a user is disallowed from enabling the
 "Unknown Sources" setting, that allows installation of apps from unknown sources.
 Unknown sources exclude adb and special apps such as trusted app stores.
 The default value is <code>false</code>.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_INSTALL_UNKNOWN_SOURCES : "no_install_unknown_sources",
/** This restriction is a device-wide version of {@link #DISALLOW_INSTALL_UNKNOWN_SOURCES}.

 Specifies if all users on the device are disallowed from enabling the
 "Unknown Sources" setting, that allows installation of apps from unknown sources.

 This restriction can be enabled by the profile owner, in which case all accounts and
 profiles will be affected.

 The default value is <code>false</code>.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_INSTALL_UNKNOWN_SOURCES_GLOBALLY : "no_install_unknown_sources_globally",
/** Specifies if a user is disallowed from configuring bluetooth.
 This does <em>not</em> restrict the user from turning bluetooth on or off.
 The default value is <code>false</code>.
 <p>This restriction doesn't prevent the user from using bluetooth. For disallowing usage of
 bluetooth completely on the device, use {@link #DISALLOW_BLUETOOTH}.
 <p>This restriction has no effect in a managed profile.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_CONFIG_BLUETOOTH : "no_config_bluetooth",
/** Specifies if bluetooth is disallowed on the device.

 <p> This restriction can only be set by the device owner and the profile owner on the
 primary user and it applies globally - i.e. it disables bluetooth on the entire device.
 <p>The default value is <code>false</code>.
 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_BLUETOOTH : "no_bluetooth",
/** Specifies if outgoing bluetooth sharing is disallowed on the device. Device owner and profile
 owner can set this restriction. When it is set by device owner, all users on this device will
 be affected.

 <p>Default is <code>true</code> for managed profiles and false for otherwise. When a device
 upgrades to {@link android.os.Build.VERSION_CODES#O}, the system sets it for all existing
 managed profiles.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_BLUETOOTH_SHARING : "no_bluetooth_sharing",
/** Specifies if a user is disallowed from transferring files over
 USB. This can only be set by device owners and profile owners on the primary user.
 The default value is <code>false</code>.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_USB_FILE_TRANSFER : "no_usb_file_transfer",
/** Specifies if a user is disallowed from configuring user
 credentials. The default value is <code>false</code>.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_CONFIG_CREDENTIALS : "no_config_credentials",
/** When set on the primary user this specifies if the user can remove other users.
 When set on a secondary user, this specifies if the user can remove itself.
 This restriction has no effect on managed profiles.
 The default value is <code>false</code>.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_REMOVE_USER : "no_remove_user",
/** Specifies if managed profiles of this user can be removed, other than by its profile owner.
 The default value is <code>false</code>.
 <p>
 This restriction has no effect on managed profiles.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_REMOVE_MANAGED_PROFILE : "no_remove_managed_profile",
/** Specifies if a user is disallowed from enabling or accessing debugging features. When set on
 the primary user, disables debugging features altogether, including USB debugging. When set
 on a managed profile or a secondary user, blocks debugging for that user only, including
 starting activities, making service calls, accessing content providers, sending broadcasts,
 installing/uninstalling packages, clearing user data, etc.
 The default value is <code>false</code>.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_DEBUGGING_FEATURES : "no_debugging_features",
/** Specifies if a user is disallowed from configuring a VPN. The default value is
 <code>false</code>. This restriction has an effect when set by device owners and, in Android
 6.0 ({@linkplain android.os.Build.VERSION_CODES#M API level 23}) or higher, profile owners.
 <p>This restriction also prevents VPNs from starting. However, in Android 7.0
 ({@linkplain android.os.Build.VERSION_CODES#N API level 24}) or higher, the system does
 start always-on VPNs created by the device or profile owner.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_CONFIG_VPN : "no_config_vpn",
/** Specifies if a user is disallowed from enabling or disabling location providers. As a
 result, user is disallowed from turning on or off location. Device owner and profile owners
 can set this restriction and it only applies on the managed user.

 <p>In a managed profile, location sharing is forced off when it's off on primary user, so
 user can still turn off location sharing on managed profile when the restriction is set by
 profile owner on managed profile.

 <p>This user restriction is different from {@link #DISALLOW_SHARE_LOCATION},
 as the device owner or profile owner can still enable or disable location mode via
 {@link DevicePolicyManager#setSecureSetting} when this restriction is on.

 <p>The default value is <code>false</code>.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see android.location.LocationManager#isProviderEnabled(String)
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_CONFIG_LOCATION : "no_config_location",
/** Specifies if date, time and timezone configuring is disallowed.

 <p>When restriction is set by device owners, it applies globally - i.e., it disables date,
 time and timezone setting on the entire device and all users will be affected. When it's set
 by profile owners, it's only applied to the managed user.
 <p>The default value is <code>false</code>.

 <p>This user restriction has no effect on managed profiles.
 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_CONFIG_DATE_TIME : "no_config_date_time",
/** Specifies if a user is disallowed from configuring Tethering
 & portable hotspots. This can only be set by device owners and profile owners on the
 primary user. The default value is <code>false</code>.
 <p>In Android 9.0 or higher, if tethering is enabled when this restriction is set,
 tethering will be automatically turned off.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_CONFIG_TETHERING : "no_config_tethering",
/** Specifies if a user is disallowed from resetting network settings
 from Settings. This can only be set by device owners and profile owners on the primary user.
 The default value is <code>false</code>.
 <p>This restriction has no effect on secondary users and managed profiles since only the
 primary user can reset the network settings of the device.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_NETWORK_RESET : "no_network_reset",
/** Specifies if a user is disallowed from factory resetting
 from Settings. This can only be set by device owners and profile owners on the primary user.
 The default value is <code>false</code>.
 <p>This restriction has no effect on secondary users and managed profiles since only the
 primary user can factory reset the device.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_FACTORY_RESET : "no_factory_reset",
/** Specifies if a user is disallowed from adding new users. This can only be set by device
 owners and profile owners on the primary user.
 The default value is <code>false</code>.
 <p>This restriction has no effect on secondary users and managed profiles since only the
 primary user can add other users.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_ADD_USER : "no_add_user",
/** Specifies if a user is disallowed from adding managed profiles.
 <p>The default value for an unmanaged user is <code>false</code>.
 For users with a device owner set, the default is <code>true</code>.
 <p>This restriction has no effect on managed profiles.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_ADD_MANAGED_PROFILE : "no_add_managed_profile",
/** Specifies if a user is disallowed from disabling application verification. The default
 value is <code>false</code>.

 <p>In Android 8.0 ({@linkplain android.os.Build.VERSION_CODES#O API level 26}) and higher,
 this is a global user restriction. If a device owner or profile owner sets this restriction,
 the system enforces app verification across all users on the device. Running in earlier
 Android versions, this restriction affects only the profile that sets it.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
ENSURE_VERIFY_APPS : "ensure_verify_apps",
/** Specifies if a user is disallowed from configuring cell
 broadcasts. This can only be set by device owners and profile owners on the primary user.
 The default value is <code>false</code>.
 <p>This restriction has no effect on secondary users and managed profiles since only the
 primary user can configure cell broadcasts.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_CONFIG_CELL_BROADCASTS : "no_config_cell_broadcasts",
/** Specifies if a user is disallowed from configuring mobile
 networks. This can only be set by device owners and profile owners on the primary user.
 The default value is <code>false</code>.
 <p>This restriction has no effect on secondary users and managed profiles since only the
 primary user can configure mobile networks.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_CONFIG_MOBILE_NETWORKS : "no_config_mobile_networks",
/** Specifies if a user is disallowed from modifying
 applications in Settings or launchers. The following actions will not be allowed when this
 restriction is enabled:
 <li>uninstalling apps</li>
 <li>disabling apps</li>
 <li>clearing app caches</li>
 <li>clearing app data</li>
 <li>force stopping apps</li>
 <li>clearing app defaults</li>
 <p>
 The default value is <code>false</code>.

 <p><strong>Note:</strong> The user will still be able to perform those actions via other
 means (such as adb). Third party apps will also be able to uninstall apps via the
 {@link android.content.pm.PackageInstaller}. {@link #DISALLOW_UNINSTALL_APPS} or
 {@link DevicePolicyManager#setUninstallBlocked(ComponentName, String, boolean)} should be
 used to prevent the user from uninstalling apps completely, and
 {@link DevicePolicyManager#addPersistentPreferredActivity(ComponentName, IntentFilter, ComponentName)}
 to add a default intent handler for a given intent filter.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_APPS_CONTROL : "no_control_apps",
/** Specifies if a user is disallowed from mounting
 physical external media. This can only be set by device owners and profile owners on the
 primary user. The default value is <code>false</code>.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_MOUNT_PHYSICAL_MEDIA : "no_physical_media",
/** Specifies if a user is disallowed from adjusting microphone volume. If set, the microphone
 will be muted. This can be set by device owners and profile owners. The default value is
 <code>false</code>.

 <p>This restriction has no effect on managed profiles.
 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_UNMUTE_MICROPHONE : "no_unmute_microphone",
/** Specifies if a user is disallowed from adjusting the master volume. If set, the master volume
 will be muted. This can be set by device owners from API 21 and profile owners from API 24.
 The default value is <code>false</code>.

 <p>When the restriction is set by profile owners, then it only applies to relevant
 profiles.

 <p>This restriction has no effect on managed profiles.
 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_ADJUST_VOLUME : "no_adjust_volume",
/** Specifies that the user is not allowed to make outgoing
 phone calls. Emergency calls are still permitted.
 The default value is <code>false</code>.
 <p>This restriction has no effect on managed profiles.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_OUTGOING_CALLS : "no_outgoing_calls",
/** Specifies that the user is not allowed to send or receive
 SMS messages. The default value is <code>false</code>.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_SMS : "no_sms",
/** Specifies if the user is not allowed to have fun. In some cases, the
 device owner may wish to prevent the user from experiencing amusement or
 joy while using the device. The default value is <code>false</code>.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_FUN : "no_fun",
/** Specifies that windows besides app windows should not be
 created. This will block the creation of the following types of windows.
 <li>{@link LayoutParams#TYPE_TOAST}</li>
 <li>{@link LayoutParams#TYPE_PHONE}</li>
 <li>{@link LayoutParams#TYPE_PRIORITY_PHONE}</li>
 <li>{@link LayoutParams#TYPE_SYSTEM_ALERT}</li>
 <li>{@link LayoutParams#TYPE_SYSTEM_ERROR}</li>
 <li>{@link LayoutParams#TYPE_SYSTEM_OVERLAY}</li>
 <li>{@link LayoutParams#TYPE_APPLICATION_OVERLAY}</li>

 <p>This can only be set by device owners and profile owners on the primary user.
 The default value is <code>false</code>.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_CREATE_WINDOWS : "no_create_windows",
/** Specifies that system error dialogs for crashed or unresponsive apps should not be shown.
 In this case, the system will force-stop the app as if the user chooses the "close app"
 option on the UI. A feedback report isn't collected as there is no way for the user to
 provide explicit consent. The default value is <code>false</code>.

 <p>When this user restriction is set by device owners, it's applied to all users. When set by
 the profile owner of the primary user or a secondary user, the restriction affects only the
 calling user. This user restriction has no effect on managed profiles.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_SYSTEM_ERROR_DIALOGS : "no_system_error_dialogs",
/** Specifies if the clipboard contents can be exported by pasting the data into other users or
 profiles. This restriction doesn't prevent import, such as someone pasting clipboard data
 from other profiles or users. The default value is {@code false}.

 <p><strong>Note</strong>: Because it's possible to extract data from screenshots using
 optical character recognition (OCR), we strongly recommend combining this user restriction
 with {@link DevicePolicyManager#setScreenCaptureDisabled(ComponentName, boolean)}.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_CROSS_PROFILE_COPY_PASTE : "no_cross_profile_copy_paste",
/** Specifies if the user is not allowed to use NFC to beam out data from apps.
 The default value is <code>false</code>.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_OUTGOING_BEAM : "no_outgoing_beam",
/** Hidden user restriction to disallow access to wallpaper manager APIs. This restriction
 generally means that wallpapers are not supported for the particular user. This user
 restriction is always set for managed profiles, because such profiles don't have wallpapers.
 @hide
 @see #DISALLOW_SET_WALLPAPER
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_WALLPAPER : "no_wallpaper",
/** User restriction to disallow setting a wallpaper. Profile owner and device owner
 are able to set wallpaper regardless of this restriction.
 The default value is <code>false</code>.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_SET_WALLPAPER : "no_set_wallpaper",
/** Specifies if the user is not allowed to reboot the device into safe boot mode.
 This can only be set by device owners and profile owners on the primary user.
 The default value is <code>false</code>.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_SAFE_BOOT : "no_safe_boot",
/** Specifies if a user is not allowed to record audio. This restriction is always enabled for
 background users. The default value is <code>false</code>.

 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
 @hide
*/
DISALLOW_RECORD_AUDIO : "no_record_audio",
/** Specifies if a user is not allowed to run in the background and should be stopped during
 user switch. The default value is <code>false</code>.

 <p>This restriction can be set by device owners and profile owners.

 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
 @hide
*/
DISALLOW_RUN_IN_BACKGROUND : "no_run_in_background",
/** Specifies if a user is not allowed to use the camera.

 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
 @hide
*/
DISALLOW_CAMERA : "no_camera",
/** Specifies if a user is not allowed to unmute the device's master volume.

 @see DevicePolicyManager#setMasterVolumeMuted(ComponentName, boolean)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
 @hide
*/
DISALLOW_UNMUTE_DEVICE : "disallow_unmute_device",
/** Specifies if a user is not allowed to use cellular data when roaming. This can only be set by
 device owners. The default value is <code>false</code>.

 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_DATA_ROAMING : "no_data_roaming",
/** Specifies if a user is not allowed to change their icon. Device owner and profile owner
 can set this restriction. When it is set by device owner, only the target user will be
 affected. The default value is <code>false</code>.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_SET_USER_ICON : "no_set_user_icon",
/** Specifies if a user is not allowed to enable the oem unlock setting. The default value is
 <code>false</code>. Setting this restriction has no effect if the bootloader is already
 unlocked.

 <p>Not for use by third-party applications.

 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
 @deprecated use {@link OemLockManager#setOemUnlockAllowedByCarrier(boolean, byte[])} instead.
 @hide
*/
DISALLOW_OEM_UNLOCK : "no_oem_unlock",
/** Specifies that the managed profile is not allowed to have unified lock screen challenge with
 the primary user.

 <p><strong>Note:</strong> Setting this restriction alone doesn't automatically set a
 separate challenge. Profile owner can ask the user to set a new password using
 {@link DevicePolicyManager#ACTION_SET_NEW_PASSWORD} and verify it using
 {@link DevicePolicyManager#isUsingUnifiedPassword(ComponentName)}.

 <p>Can be set by profile owners. It only has effect on managed profiles when set by managed
 profile owner. Has no effect on non-managed profiles or users.
 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_UNIFIED_PASSWORD : "no_unified_password",
/** Allows apps in the parent profile to handle web links from the managed profile.

 This user restriction has an effect only in a managed profile.
 If set:
 Intent filters of activities in the parent profile with action
 {@link android.content.Intent#ACTION_VIEW},
 category {@link android.content.Intent#CATEGORY_BROWSABLE}, scheme http or https, and which
 define a host can handle intents from the managed profile.
 The default value is <code>false</code>.

 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
ALLOW_PARENT_PROFILE_APP_LINKING : "allow_parent_profile_app_linking",
/** Specifies if a user is not allowed to use Autofill Services.

 <p>Device owner and profile owner can set this restriction. When it is set by device owner,
 only the target user will be affected.

 <p>The default value is <code>false</code>.

 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_AUTOFILL : "no_autofill",
/** Specifies if the contents of a user's screen is not allowed to be captured for artificial
 intelligence purposes.

 <p>Device owner and profile owner can set this restriction. When it is set by device owner,
 only the target user will be affected.

 <p>The default value is <code>false</code>.

 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_CONTENT_CAPTURE : "no_content_capture",
/** Specifies if the current user is able to receive content suggestions for selections based on
 the contents of their screen.

 <p>Device owner and profile owner can set this restriction. When it is set by device owner,
 only the target user will be affected.

 <p>The default value is <code>false</code>.

 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_CONTENT_SUGGESTIONS : "no_content_suggestions",
/** Specifies if user switching is blocked on the current user.

 <p> This restriction can only be set by the device owner, it will be applied to all users.
 Device owner can still switch user via
 {@link DevicePolicyManager#switchUser(ComponentName, android.os.UserHandle)} when this restriction is
 set.

 <p>The default value is <code>false</code>.

 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_USER_SWITCH : "no_user_switch",
/** Specifies whether the user can share file / picture / data from the primary user into the
 managed profile, either by sending them from the primary side, or by picking up data within
 an app in the managed profile.
 <p>
 When a managed profile is created, the system allows the user to send data from the primary
 side to the profile by setting up certain default cross profile intent filters. If
 this is undesired, this restriction can be set to disallow it. Note that this restriction
 will not block any sharing allowed by explicit
 {@link DevicePolicyManager#addCrossProfileIntentFilter} calls by the profile owner.
 <p>
 This restriction is only meaningful when set by profile owner. When it is set by device
 owner, it does not have any effect.
 <p>
 The default value is <code>false</code>.

 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_SHARE_INTO_MANAGED_PROFILE : "no_sharing_into_profile",
/** Specifies whether the user is allowed to print.

 This restriction can be set by device or profile owner.

 The default value is {@code false}.

 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_PRINTING : "no_printing",
/** Specifies whether the user is allowed to modify private DNS settings.

 <p>The default value is <code>false</code>.

 <p>This user restriction can only be applied by the Device Owner.
 <p>Key for user restrictions.
 <p>Type: Boolean
 @see DevicePolicyManager#addUserRestriction(ComponentName, String)
 @see DevicePolicyManager#clearUserRestriction(ComponentName, String)
 @see #getUserRestrictions()
*/
DISALLOW_CONFIG_PRIVATE_DNS : "disallow_config_private_dns",
/** Application restriction key that is used to indicate the pending arrival
 of real restrictions for the app.

 <p>
 Applications that support restrictions should check for the presence of this key.
 A <code>true</code> value indicates that restrictions may be applied in the near
 future but are not available yet. It is the responsibility of any
 management application that sets this flag to update it when the final
 restrictions are enforced.

 <p>Key for application restrictions.
 <p>Type: Boolean
 @see android.app.admin.DevicePolicyManager#setApplicationRestrictions(
      android.content.ComponentName, String, Bundle)
 @see android.app.admin.DevicePolicyManager#getApplicationRestrictions(
      android.content.ComponentName, String)
*/
KEY_RESTRICTIONS_PENDING : "restrictions_pending",
/** Extra containing a name for the user being created. Optional parameter passed to
 ACTION_CREATE_USER activity.
 @hide
*/
EXTRA_USER_NAME : "android.os.extra.USER_NAME",
/** Extra containing account name for the user being created. Optional parameter passed to
 ACTION_CREATE_USER activity.
 @hide
*/
EXTRA_USER_ACCOUNT_NAME : "android.os.extra.USER_ACCOUNT_NAME",
/** Extra containing account type for the user being created. Optional parameter passed to
 ACTION_CREATE_USER activity.
 @hide
*/
EXTRA_USER_ACCOUNT_TYPE : "android.os.extra.USER_ACCOUNT_TYPE",
/** Extra containing account-specific data for the user being created. Optional parameter passed
 to ACTION_CREATE_USER activity.
 @hide
*/
EXTRA_USER_ACCOUNT_OPTIONS : "android.os.extra.USER_ACCOUNT_OPTIONS",
/**@hide */
PIN_VERIFICATION_FAILED_INCORRECT : "-3",
/**@hide */
PIN_VERIFICATION_FAILED_NOT_SET : "-2",
/**@hide */
PIN_VERIFICATION_SUCCESS : "-1",
/** Sent when user restrictions have changed.

 @hide
*/
ACTION_USER_RESTRICTIONS_CHANGED : "android.os.action.USER_RESTRICTIONS_CHANGED",
/** Error result indicating that this user is not allowed to add other users on this device.
 This is a result code returned from the activity created by the intent
 {@link #createUserCreationIntent(String, String, String, android.os.PersistableBundle)}.
*/
USER_CREATION_FAILED_NOT_PERMITTED : "1",
/** Error result indicating that no more users can be created on this device.
 This is a result code returned from the activity created by the intent
 {@link #createUserCreationIntent(String, String, String, android.os.PersistableBundle)}.
*/
USER_CREATION_FAILED_NO_MORE_USERS : "2",
/** Indicates that users are switchable.
 @hide
*/
SWITCHABILITY_STATUS_OK : "0",
/** Indicated that the user is in a phone call.
 @hide
*/
SWITCHABILITY_STATUS_USER_IN_CALL : "1",
/** Indicates that user switching is disallowed ({@link #DISALLOW_USER_SWITCH} is set).
 @hide
*/
SWITCHABILITY_STATUS_USER_SWITCH_DISALLOWED : "2",
/** Indicates that the system user is locked and user switching is not allowed.
 @hide
*/
SWITCHABILITY_STATUS_SYSTEM_USER_LOCKED : "4",
/** Indicates user operation is successful.
*/
USER_OPERATION_SUCCESS : "0",
/** Indicates user operation failed for unknown reason.
*/
USER_OPERATION_ERROR_UNKNOWN : "1",
/** Indicates user operation failed because target user is a managed profile.
*/
USER_OPERATION_ERROR_MANAGED_PROFILE : "2",
/** Indicates user operation failed because maximum running user limit has been reached.
*/
USER_OPERATION_ERROR_MAX_RUNNING_USERS : "3",
/** Indicates user operation failed because the target user is in the foreground.
*/
USER_OPERATION_ERROR_CURRENT_USER : "4",
/** Indicates user operation failed because device has low data storage.
*/
USER_OPERATION_ERROR_LOW_STORAGE : "5",
/** Indicates user operation failed because maximum user limit has been reached.
*/
USER_OPERATION_ERROR_MAX_USERS : "6",
/**
@hide 
*/
get : function(  ) {},

/**Returns whether this device supports multiple users with their own login and customizable
 space.
@return {Boolean} whether the device supports multiple users.
*/
supportsMultipleUsers : function(  ) {},

/**
@hide 
@return {Boolean} Whether the device is running with split system user. It means the system user and
 primary user are two separate users. Previously system user and primary user are combined as
 a single owner user.  see @link {android.os.UserHandle#USER_OWNER}
*/
isSplitSystemUser : function(  ) {},

/**
@return {Boolean} Whether guest user is always ephemeral
@hide 
*/
isGuestUserEphemeral : function(  ) {},

/**
@deprecated use {@link #getUserSwitchability()} instead.
@removed 
@hide 
*/
canSwitchUsers : function(  ) {},

/**Returns whether switching users is currently allowed.
 <p>
 Switching users is not allowed in the following cases:
 <li>the user is in a phone call</li>
 <li>{@link #DISALLOW_USER_SWITCH} is set</li>
 <li>system user hasn't been unlocked yet</li>
@return {Number} A {@link UserSwitchabilityResult} flag indicating if the user is switchable.
@hide 
*/
getUserSwitchability : function(  ) {},

/**Returns the user handle for the user that this process is running under.
@return {Number} the user handle of this process.
@hide 
*/
getUserHandle : function(  ) {},

/**Returns the user name of the user making this call.  This call is only
 available to applications on the system image; it requires the
 {@code android.permission.MANAGE_USERS} or {@code android.permission.GET_ACCOUNTS_PRIVILEGED}
 permissions.
@return {String} the user name
*/
getUserName : function(  ) {},

/**Returns whether user name has been set.
 <p>This method can be used to check that the value returned by {@link #getUserName}() was
 set by the user and is not a placeholder string provided by the system.
@hide 
*/
isUserNameSet : function(  ) {},

/**Used to determine whether the user making this call is subject to
 teleportations.

 <p>As of {@link android.os.Build.VERSION_CODES#LOLLIPOP}, this method can
 now automatically identify goats using advanced goat recognition technology.</p>
@return {Boolean} Returns true if the user making this call is a goat.
*/
isUserAGoat : function(  ) {},

/**Used to check if this process is running under the primary user. The primary user
 is the first human user on a device.
@return {Boolean} whether this process is running under the primary user.
@hide 
*/
isPrimaryUser : function(  ) {},

/**Used to check if this process is running under the system user. The system user
 is the initial user that is implicitly created on first boot and hosts most of the
 system services.
@return {Boolean} whether this process is running under the system user.
*/
isSystemUser : function(  ) {},

/**Used to check if this process is running as an admin user. An admin user is allowed to
 modify or configure certain settings that aren't available to non-admin users,
 create and delete additional users, etc. There can be more than one admin users.
@return {Boolean} whether this process is running under an admin user.
@hide 
*/
isAdminUser : function(  ) {},

/**
@hide Returns whether the provided user is an admin user. There can be more than one admin
 user.
*/
isUserAdmin : function(  ) {},

/**
@hide 
@deprecated Use {@link #isRestrictedProfile()}
*/
isLinkedUser : function(  ) {},

/**Used to check if this process is running under a restricted profile. Restricted profiles
 may have a reduced number of available apps, app restrictions, and account restrictions.
@return {Boolean} whether this process is running under a restricted profile.
@hide 
*/
isRestrictedProfile : function(  ) {},

/**Check if a user is a restricted profile. Restricted profiles may have a reduced number of
 available apps, app restrictions, and account restrictions.
@param {Object {UserHandle}} user the user to check
@return {Boolean} whether the user is a restricted profile.
@hide 
*/
isRestrictedProfile : function(  ) {},

/**Checks if specified user can have restricted profile.
@hide 
*/
canHaveRestrictedProfile : function(  ) {},

/**Returns whether the calling user has at least one restricted profile associated with it.
@return {Boolean} 
@hide 
*/
hasRestrictedProfiles : function(  ) {},

/**Checks if a user is a guest user.
@return {Boolean} whether user is a guest user.
@hide 
*/
isGuestUser : function(  ) {},

/**Used to check if this process is running under a guest user. A guest user may be transient.
@return {Boolean} whether this process is running under a guest user.
@hide 
*/
isGuestUser : function(  ) {},

/**Checks if the calling app is running in a demo user. When running in a demo user,
 apps can be more helpful to the user, or explain their features in more detail.
@return {Boolean} whether the caller is a demo user.
*/
isDemoUser : function(  ) {},

/**Checks if the calling app is running in a managed profile.
@return {Boolean} whether the caller is in a managed profile.
@hide 
*/
isManagedProfile : function(  ) {},

/**Checks if the specified user is a managed profile.
 Requires {@link android.Manifest.permission#MANAGE_USERS} permission, otherwise the caller
 must be in the same profile group of specified user.
@return {Boolean} whether the specified user is a managed profile.
@hide 
*/
isManagedProfile : function(  ) {},

/**Gets badge for a managed profile.
 Requires {@link android.Manifest.permission#MANAGE_USERS} permission, otherwise the caller
 must be in the same profile group of specified user.
@return {Number} which badge to use for the managed profile badge id will be less than
         UserManagerService.getMaxManagedProfiles()
@hide 
*/
getManagedProfileBadge : function(  ) {},

/**Checks if the calling app is running as an ephemeral user.
@return {Boolean} whether the caller is an ephemeral user.
@hide 
*/
isEphemeralUser : function(  ) {},

/**Returns whether the specified user is ephemeral.
@hide 
*/
isUserEphemeral : function(  ) {},

/**Return whether the given user is actively running.  This means that
 the user is in the "started" state, not "stopped" -- it is currently
 allowed to run code through scheduled alarms, receiving broadcasts,
 etc.  A started user may be either the current foreground user or a
 background user; the result here does not distinguish between the two.

 <p>Note prior to Android Nougat MR1 (SDK version <= 24;
 {@link android.os.Build.VERSION_CODES#N}, this API required a system permission
 in order to check other profile's status.
 Since Android Nougat MR1 (SDK version >= 25;
 {@link android.os.Build.VERSION_CODES#N_MR1}), the restriction has been relaxed, and now
 it'll accept any {@link android.os.UserHandle} within the same profile group as the caller.
@param {Object {UserHandle}} user The user to retrieve the running state for.
*/
isUserRunning : function(  ) {},

/**{@hide}
*/
isUserRunning : function(  ) {},

/**Return whether the given user is actively running <em>or</em> stopping.
 This is like {@link #isUserRunning}(UserHandle), but will also return
 true if the user had been running but is in the process of being stopped
 (but is not yet fully stopped, and still running some code).

 <p>Note prior to Android Nougat MR1 (SDK version <= 24;
 {@link android.os.Build.VERSION_CODES#N}, this API required a system permission
 in order to check other profile's status.
 Since Android Nougat MR1 (SDK version >= 25;
 {@link android.os.Build.VERSION_CODES#N_MR1}), the restriction has been relaxed, and now
 it'll accept any {@link android.os.UserHandle} within the same profile group as the caller.
@param {Object {UserHandle}} user The user to retrieve the running state for.
*/
isUserRunningOrStopping : function(  ) {},

/**Return whether the calling user is running in an "unlocked" state.
 <p>
 On devices with direct boot, a user is unlocked only after they've
 entered their credentials (such as a lock pattern or PIN). On devices
 without direct boot, a user is unlocked as soon as it starts.
 <p>
 When a user is locked, only device-protected data storage is available.
 When a user is unlocked, both device-protected and credential-protected
 private app data storage is available.
@see Intent#ACTION_USER_UNLOCKED
@see Context#createDeviceProtectedStorageContext()
*/
isUserUnlocked : function(  ) {},

/**Return whether the given user is running in an "unlocked" state.
 <p>
 On devices with direct boot, a user is unlocked only after they've
 entered their credentials (such as a lock pattern or PIN). On devices
 without direct boot, a user is unlocked as soon as it starts.
 <p>
 When a user is locked, only device-protected data storage is available.
 When a user is unlocked, both device-protected and credential-protected
 private app data storage is available.
 <p>Requires {@code android.permission.MANAGE_USERS} or
 {@code android.permission.INTERACT_ACROSS_USERS}, otherwise specified {@link android.os.UserHandle user}
 must be the calling user or a managed profile associated with it.
@param {Object {UserHandle}} user to retrieve the unlocked state for.
@see Intent#ACTION_USER_UNLOCKED
@see Context#createDeviceProtectedStorageContext()
*/
isUserUnlocked : function(  ) {},

/**{@hide}
*/
isUserUnlocked : function(  ) {},

/**{@hide}
*/
isUserUnlockingOrUnlocked : function(  ) {},

/**{@hide}
*/
isUserUnlockingOrUnlocked : function(  ) {},

/**Return the time when the calling user started in elapsed milliseconds since boot,
 or 0 if not started.
@hide 
*/
getUserStartRealtime : function(  ) {},

/**Return the time when the calling user was unlocked elapsed milliseconds since boot,
 or 0 if not unlocked.
@hide 
*/
getUserUnlockRealtime : function(  ) {},

/**Returns the UserInfo object describing a specific user.
 Requires {@link android.Manifest.permission#MANAGE_USERS} permission.
@param {Number} userHandle the user handle of the user whose information is being requested.
@return {Object {android.content.pm.UserInfo}} the UserInfo object for a specific user.
@hide 
*/
getUserInfo : function(  ) {},

/**
@param {String} restrictionKey the string key representing the restriction
@param {Object {UserHandle}} userHandle the UserHandle of the user for whom to retrieve the restrictions.
@param userHandle the UserHandle of the user for whom to retrieve the restrictions.
@return {Number} The source of user restriction. Any combination of {@link #RESTRICTION_NOT_SET},
         {@link #RESTRICTION_SOURCE_SYSTEM}, {@link #RESTRICTION_SOURCE_DEVICE_OWNER}
         and {@link #RESTRICTION_SOURCE_PROFILE_OWNER}
@deprecated use {@link #getUserRestrictionSources(String, int)} instead.
*/
getUserRestrictionSource : function(  ) {},

/**
@param {String} restrictionKey the string key representing the restriction
@param {Object {UserHandle}} userHandle the UserHandle of the user for whom to retrieve the restrictions.
@param userHandle the UserHandle of the user for whom to retrieve the restrictions.
@return {Object {java.util.List}} a list of user ids enforcing this restriction.
*/
getUserRestrictionSources : function(  ) {},

/**Returns the user-wide restrictions imposed on this user.
@return {Object {android.os.Bundle}} a Bundle containing all the restrictions.
*/
getUserRestrictions : function(  ) {},

/**Returns the user-wide restrictions imposed on the user specified by <code>userHandle</code>.
@param {Object {UserHandle}} userHandle the UserHandle of the user for whom to retrieve the restrictions.
@return {Object {android.os.Bundle}} a Bundle containing all the restrictions.
*/
getUserRestrictions : function(  ) {},

/**
@param {String} restrictionKey the string key representing the restriction
@param {Object {UserHandle}} userHandle the UserHandle of the user for whom to retrieve the restrictions.
@param userHandle the UserHandle of the user for whom to retrieve the restrictions.
*/
hasBaseUserRestriction : function(  ) {},

/**This will no longer work.  Device owners and profile owners should use
 {@link DevicePolicyManager#addUserRestriction(ComponentName, String)} instead.
*/
setUserRestrictions : function(  ) {},

/**This will no longer work.  Device owners and profile owners should use
 {@link DevicePolicyManager#addUserRestriction(ComponentName, String)} instead.
*/
setUserRestrictions : function(  ) {},

/**Sets the value of a specific restriction.
 Requires the MANAGE_USERS permission.
@param {String} key the key of the restriction
@param {Boolean} value the value for the restriction
@deprecated use {@link android.app.admin.DevicePolicyManager#addUserRestriction(
 android.content.ComponentName, String)} or
 {@link android.app.admin.DevicePolicyManager#clearUserRestriction(
 android.content.ComponentName, String)} instead.
*/
setUserRestriction : function(  ) {},

/**
@param {String} key the key of the restriction
@param {Boolean} value the value for the restriction
@param {Object {UserHandle}} userHandle the user whose restriction is to be changed.
@param userHandle the user whose restriction is to be changed.
@deprecated use {@link android.app.admin.DevicePolicyManager#addUserRestriction(
 android.content.ComponentName, String)} or
 {@link android.app.admin.DevicePolicyManager#clearUserRestriction(
 android.content.ComponentName, String)} instead.
*/
setUserRestriction : function(  ) {},

/**Returns whether the current user has been disallowed from performing certain actions
 or setting certain settings.
@param {String} restrictionKey The string key representing the restriction.
@return {Boolean} {@code true} if the current user has the given restriction, {@code false} otherwise.
*/
hasUserRestriction : function(  ) {},

/**
@param {String} restrictionKey the string key representing the restriction
@param {Object {UserHandle}} userHandle the UserHandle of the user for whom to retrieve the restrictions.
@param userHandle the UserHandle of the user for whom to retrieve the restrictions.
*/
hasUserRestriction : function(  ) {},

/**
@hide Returns whether any user on the device has the given user restriction set.
*/
hasUserRestrictionOnAnyUser : function(  ) {},

/**Return the serial number for a user.  This is a device-unique
 number assigned to that user; if the user is deleted and then a new
 user created, the new users will not be given the same serial number.
@param {Object {UserHandle}} user The user whose serial number is to be retrieved.
@return {Number} The serial number of the given user; returns -1 if the
 given UserHandle does not exist.
@see #getUserForSerialNumber(long)
*/
getSerialNumberForUser : function(  ) {},

/**Return the user associated with a serial number previously
 returned by {@link #getSerialNumberForUser}(UserHandle).
@param {Number} serialNumber The serial number of the user that is being
 retrieved.
@return {Object {android.os.UserHandle}} Return the user associated with the serial number, or null
 if there is not one.
@see #getSerialNumberForUser(UserHandle)
*/
getUserForSerialNumber : function(  ) {},

/**Creates a user with the specified name and options. For non-admin users, default user
 restrictions are going to be applied.
 Requires {@link android.Manifest.permission#MANAGE_USERS} permission.
@param {String} name the user's name
@param {Number} flags flags that identify the type of user and other properties.
@see UserInfo
@return {Object {android.content.pm.UserInfo}} the UserInfo object for the created user, or null if the user could not be created.
@hide 
*/
createUser : function(  ) {},

/**Creates a guest user and configures it.
@param {Object {Context}} context an application context
@param {String} name the name to set for the user
@hide 
*/
createGuest : function(  ) {},

/**Creates a user with the specified name and options as a profile of another user.
 Requires {@link android.Manifest.permission#MANAGE_USERS} permission.
@param {String} name the user's name
@param {Number} flags flags that identify the type of user and other properties.
@param {Number} userHandle new user will be a profile of this user.
@return {Object {android.content.pm.UserInfo}} the {@link UserInfo} object for the created user, or null if the user
         could not be created.
@hide 
*/
createProfileForUser : function(  ) {},

/**Version of {@link #createProfileForUser(String, int, int)} that allows you to specify
 any packages that should not be installed in the new profile by default, these packages can
 still be installed later by the user if needed.
@param {String} name the user's name
@param {Number} flags flags that identify the type of user and other properties.
@param {Number} userHandle new user will be a profile of this user.
@param {Object {java.lang.String[]}} disallowedPackages packages that will not be installed in the profile being created.
@return {Object {android.content.pm.UserInfo}} the {@link UserInfo} object for the created user, or null if the user
         could not be created.
@hide 
*/
createProfileForUser : function(  ) {},

/**Similar to {@link #createProfileForUser(String, int, int, String[])}
 except bypassing the checking of {@link android.os.UserManager#DISALLOW_ADD_MANAGED_PROFILE}.
 Requires {@link android.Manifest.permission#MANAGE_USERS} permission.
@see #createProfileForUser(String, int, int, String[])
@hide 
*/
createProfileForUserEvenWhenDisallowed : function(  ) {},

/**Creates a restricted profile with the specified name. This method also sets necessary
 restrictions and adds shared accounts.
@param {String} name profile's name
@return {Object {android.content.pm.UserInfo}} UserInfo object for the created user, or null if the user could not be created.
@hide 
*/
createRestrictedProfile : function(  ) {},

/**Returns an intent to create a user for the provided name and account name. The name
 and account name will be used when the setup process for the new user is started.
 <p>
 The intent should be launched using startActivityForResult and the return result will
 indicate if the user consented to adding a new user and if the operation succeeded. Any
 errors in creating the user will be returned in the result code. If the user cancels the
 request, the return result will be {@link Activity#RESULT_CANCELED}. On success, the
 result code will be {@link Activity#RESULT_OK}.
 <p>
 Use {@link #supportsMultipleUsers}() to first check if the device supports this operation
 at all.
 <p>
 The new user is created but not initialized. After switching into the user for the first
 time, the preferred user name and account information are used by the setup process for that
 user.
@param {String} userName Optional name to assign to the user.
@param {String} accountName Optional account name that will be used by the setup wizard to initialize
                    the user.
@param {String} accountType Optional account type for the account to be created. This is required
                    if the account name is specified.
@param {Object {PersistableBundle}} accountOptions Optional bundle of data to be passed in during account creation in the
                       new user via {@link AccountManager#addAccount(String, String, String[],
                       Bundle, android.app.Activity, android.accounts.AccountManagerCallback,
                       Handler)}.
@return {Object {android.content.Intent}} An Intent that can be launched from an Activity.
@see #USER_CREATION_FAILED_NOT_PERMITTED
@see #USER_CREATION_FAILED_NO_MORE_USERS
@see #supportsMultipleUsers
*/
createUserCreationIntent : function(  ) {},

/**
@hide Returns the preferred account name for user creation.
*/
getSeedAccountName : function(  ) {},

/**
@hide Returns the preferred account type for user creation.
*/
getSeedAccountType : function(  ) {},

/**
@hide Returns the preferred account's options bundle for user creation.
@return {Object {android.os.PersistableBundle}} Any options set by the requestor that created the user.
*/
getSeedAccountOptions : function(  ) {},

/**
@param {Number} userId
@param {String} accountName
@param {String} accountType
@param {Object {PersistableBundle}} accountOptions
@param accountOptions
@see #createUserCreationIntent(String, String, String, PersistableBundle)
*/
setSeedAccountData : function(  ) {},

/**
@hide Clears the seed information used to create this user.
*/
clearSeedAccountData : function(  ) {},

/**
@param {Number} userHandle
@param userHandle
@return {Boolean} 
*/
markGuestForDeletion : function(  ) {},

/**Sets the user as enabled, if such an user exists.

 <p>Requires {@link android.Manifest.permission#MANAGE_USERS} permission.

 <p>Note that the default is true, it's only that managed profiles might not be enabled.
 Also ephemeral users can be disabled to indicate that their removal is in progress and they
 shouldn't be re-entered. Therefore ephemeral users should not be re-enabled once disabled.
@param {Number} userId the id of the profile to enable
@hide 
*/
setUserEnabled : function(  ) {},

/**Assigns admin privileges to the user, if such a user exists.

 <p>Requires {@link android.Manifest.permission#MANAGE_USERS} and
 {@link android.Manifest.permission#INTERACT_ACROSS_USERS_FULL} permissions.
@param {Number} userHandle the id of the user to become admin
@hide 
*/
setUserAdmin : function(  ) {},

/**Evicts the user's credential encryption key from memory by stopping and restarting the user.
@hide 
*/
evictCredentialEncryptionKey : function(  ) {},

/**Return the number of users currently created on the device.
*/
getUserCount : function(  ) {},

/**Returns information for all users on this device, including ones marked for deletion.
 To retrieve only users that are alive, use {@link #getUsers}(boolean).
 <p>
 Requires {@link android.Manifest.permission#MANAGE_USERS} permission.
@return {Object {java.util.List}} the list of users that exist on the device.
@hide 
*/
getUsers : function(  ) {},

/**Returns serial numbers of all users on this device.
@param {Boolean} excludeDying specify if the list should exclude users being removed.
@return {Number} the list of serial numbers of users that exist on the device.
@hide 
*/
getSerialNumbersOfUsers : function(  ) {},

/**
@return {String} the user's account name, null if not found.
@hide 
*/
getUserAccount : function(  ) {},

/**Set account name for the given user.
@hide 
*/
setUserAccount : function(  ) {},

/**Returns information for Primary user.
 Requires {@link android.Manifest.permission#MANAGE_USERS} permission.
@return {Object {android.content.pm.UserInfo}} the Primary user, null if not found.
@hide 
*/
getPrimaryUser : function(  ) {},

/**Checks whether it's possible to add more users. Caller must hold the MANAGE_USERS
 permission.
@return {Boolean} true if more users can be added, false if limit has been reached.
@hide 
*/
canAddMoreUsers : function(  ) {},

/**Checks whether it's possible to add more managed profiles. Caller must hold the MANAGE_USERS
 permission.
 if allowedToRemoveOne is true and if the user already has a managed profile, then return if
 we could add a new managed profile to this user after removing the existing one.
@return {Boolean} true if more managed profiles can be added, false if limit has been reached.
@hide 
*/
canAddMoreManagedProfiles : function(  ) {},

/**Returns list of the profiles of userHandle including
 userHandle itself.
 Note that this returns both enabled and not enabled profiles. See
 {@link #getEnabledProfiles}(int) if you need only the enabled ones.

 Requires {@link android.Manifest.permission#MANAGE_USERS} permission.
@param {Number} userHandle profiles of this user will be returned.
@return {Object {java.util.List}} the list of profiles.
@hide 
*/
getProfiles : function(  ) {},

/**Requires {@link android.Manifest.permission#MANAGE_USERS} permission.
@param {Number} userId one of the two user ids to check.
@param {Number} otherUserId one of the two user ids to check.
@return {Boolean} true if the two user ids are in the same profile group.
@hide 
*/
isSameProfileGroup : function(  ) {},

/**Returns list of the profiles of userHandle including
 userHandle itself.
 Note that this returns only enabled.

 Requires {@link android.Manifest.permission#MANAGE_USERS} permission.
@param {Number} userHandle profiles of this user will be returned.
@return {Object {java.util.List}} the list of profiles.
@hide 
*/
getEnabledProfiles : function(  ) {},

/**Returns a list of UserHandles for profiles associated with the user that the calling process
 is running on, including the user itself.
@return {Object {java.util.List}} A non-empty list of UserHandles associated with the calling user.
*/
getUserProfiles : function(  ) {},

/**Returns a list of ids for profiles associated with the specified user including the user
 itself.
@param {Number} userId      id of the user to return profiles for
@param {Boolean} enabledOnly whether return only {@link UserInfo#isEnabled() enabled} profiles
@return {Number} A non-empty list of ids of profiles associated with the specified user.
@hide 
*/
getProfileIds : function(  ) {},

/**
@see #getProfileIds(int, boolean)
@hide 
*/
getProfileIdsWithDisabled : function(  ) {},

/**
@see #getProfileIds(int, boolean)
@hide 
*/
getEnabledProfileIds : function(  ) {},

/**Returns the device credential owner id of the profile from
 which this method is called, or userHandle if called from a user that
 is not a profile.
@hide 
*/
getCredentialOwnerProfile : function(  ) {},

/**Returns the parent of the profile which this method is called from
 or null if called from a user that is not a profile.
@hide 
*/
getProfileParent : function(  ) {},

/**Get the parent of a user profile.
@param {Object {UserHandle}} user the handle of the user profile
@return {Object {android.os.UserHandle}} the parent of the user or {@code null} if the user is not profile
@hide 
*/
getProfileParent : function(  ) {},

/**Enables or disables quiet mode for a managed profile. If quiet mode is enabled, apps in a
 managed profile don't run, generate notifications, or consume data or battery.
 <p>
 If a user's credential is needed to turn off quiet mode, a confirm credential screen will be
 shown to the user.
 <p>
 The change may not happen instantly, however apps can listen for
 {@link Intent#ACTION_MANAGED_PROFILE_AVAILABLE} and
 {@link Intent#ACTION_MANAGED_PROFILE_UNAVAILABLE} broadcasts in order to be notified of
 the change of the quiet mode. Apps can also check the current state of quiet mode by
 calling {@link #isQuietModeEnabled}(UserHandle).
 <p>
 The caller must either be the foreground default launcher or have one of these permissions:
 {@code MANAGE_USERS} or {@code MODIFY_QUIET_MODE}.
@param {Boolean} enableQuietMode whether quiet mode should be enabled or disabled
@param {Object {UserHandle}} userHandle user handle of the profile
@return {Boolean} {@code false} if user's credential is needed in order to turn off quiet mode,
         {@code true} otherwise
@throws SecurityException if the caller is invalid
@throws IllegalArgumentException if {@code userHandle} is not a managed profile
@see #isQuietModeEnabled(UserHandle)
*/
requestQuietModeEnabled : function(  ) {},

/**Similar to {@link #requestQuietModeEnabled(boolean, android.os.UserHandle)}, except you can specify
 a target to start when user is unlocked. If {@code target} is specified, caller must have
 the {@link android.Manifest.permission#MANAGE_USERS} permission.
@see {@link #requestQuietModeEnabled(boolean, UserHandle)}
@hide 
*/
requestQuietModeEnabled : function(  ) {},

/**Returns whether the given profile is in quiet mode or not.
 Notes: Quiet mode is only supported for managed profiles.
@param {Object {UserHandle}} userHandle The user handle of the profile to be queried.
@return {Boolean} true if the profile is in quiet mode, false otherwise.
*/
isQuietModeEnabled : function(  ) {},

/**If the target user is a managed profile of the calling user or the caller
 is itself a managed profile, then this returns a badged copy of the given
 icon to be able to distinguish it from the original icon. For badging an
 arbitrary drawable use {@link #getBadgedDrawableForUser(
 android.graphics.drawable.Drawable, android.os.UserHandle, android.graphics.Rect, int)}.
 <p>
 If the original drawable is a BitmapDrawable and the backing bitmap is
 mutable as per {@link android.graphics.Bitmap#isMutable()}, the badging
 is performed in place and the original drawable is returned.
 </p>
@param {Object {Drawable}} icon The icon to badge.
@param {Object {UserHandle}} user The target user.
@return {Object {android.graphics.drawable.Drawable}} A drawable that combines the original icon and a badge as
         determined by the system.
@removed 
*/
getBadgedIconForUser : function(  ) {},

/**If the target user is a managed profile of the calling user or the caller
 is itself a managed profile, then this returns a badged copy of the given
 drawable allowing the user to distinguish it from the original drawable.
 The caller can specify the location in the bounds of the drawable to be
 badged where the badge should be applied as well as the density of the
 badge to be used.
 <p>
 If the original drawable is a BitmapDrawable and the backing bitmap is
 mutable as per {@link android.graphics.Bitmap#isMutable()}, the badging
 is performed in place and the original drawable is returned.
 </p>
@param {Object {Drawable}} badgedDrawable The drawable to badge.
@param {Object {UserHandle}} user The target user.
@param {Object {Rect}} badgeLocation Where in the bounds of the badged drawable to place
         the badge. If it's {@code null}, the badge is applied on top of the entire
         drawable being badged.
@param {Number} badgeDensity The optional desired density for the badge as per
         {@link android.util.DisplayMetrics#densityDpi}. If it's not positive,
         the density of the display is used.
@return {Object {android.graphics.drawable.Drawable}} A drawable that combines the original drawable and a badge as
         determined by the system.
@removed 
*/
getBadgedDrawableForUser : function(  ) {},

/**If the target user is a managed profile of the calling user or the caller
 is itself a managed profile, then this returns a copy of the label with
 badging for accessibility services like talkback. E.g. passing in "Email"
 and it might return "Work Email" for Email in the work profile.
@param {Object {CharSequence}} label The label to change.
@param {Object {UserHandle}} user The target user.
@return {Object {java.lang.CharSequence}} A label that combines the original label and a badge as
         determined by the system.
@removed 
*/
getBadgedLabelForUser : function(  ) {},

/**Returns information for all users on this device. Requires
 {@link android.Manifest.permission#MANAGE_USERS} permission.
@param {Boolean} excludeDying specify if the list should exclude users being
            removed.
@return {Object {java.util.List}} the list of users that were created.
@hide 
*/
getUsers : function(  ) {},

/**Removes a user and all associated data.
 Requires {@link android.Manifest.permission#MANAGE_USERS} permission.
@param {Number} userHandle the integer handle of the user, where 0 is the primary user.
@hide 
*/
removeUser : function(  ) {},

/**Removes a user and all associated data.
@param {Object {UserHandle}} user the user that needs to be removed.
@return {Boolean} {@code true} if the user was successfully removed, {@code false} otherwise.
@throws IllegalArgumentException if {@code user} is {@code null}
@hide 
*/
removeUser : function(  ) {},

/**Similar to {@link #removeUser}(int) except bypassing the checking of
 {@link android.os.UserManager#DISALLOW_REMOVE_USER}
 or {@link android.os.UserManager#DISALLOW_REMOVE_MANAGED_PROFILE}.
@see {@link #removeUser(int)}
@hide 
*/
removeUserEvenWhenDisallowed : function(  ) {},

/**Updates the user's name.
 Requires {@link android.Manifest.permission#MANAGE_USERS} permission.
@param {Number} userHandle the user's integer handle
@param {String} name the new name for the user
@hide 
*/
setUserName : function(  ) {},

/**Updates the calling user's name.
 Requires {@link android.Manifest.permission#MANAGE_USERS} permission.
@param {String} name the new name for the user
@hide 
*/
setUserName : function(  ) {},

/**Sets the user's photo.
@param {Number} userHandle the user for whom to change the photo.
@param {Object {Bitmap}} icon the bitmap to set as the photo.
@hide 
*/
setUserIcon : function(  ) {},

/**Sets the calling user's photo.
 Requires {@link android.Manifest.permission#MANAGE_USERS} permission.
@param {Object {Bitmap}} icon the bitmap to set as the photo.
@hide 
*/
setUserIcon : function(  ) {},

/**Returns a file descriptor for the user's photo. PNG data can be read from this file.
@param {Number} userHandle the user whose photo we want to read.
@return {Object {android.graphics.Bitmap}} a {@link Bitmap} of the user's photo, or null if there's no photo.
@see com.android.internal.util.UserIcons#getDefaultUserIcon for a default.
@hide 
*/
getUserIcon : function(  ) {},

/**Returns a Bitmap for the calling user's photo.
 Requires {@link android.Manifest.permission#MANAGE_USERS}
 or {@link android.Manifest.permission#GET_ACCOUNTS_PRIVILEGED} permissions.
@return {Object {android.graphics.Bitmap}} a {@link Bitmap} of the user's photo, or null if there's no photo.
@see com.android.internal.util.UserIcons#getDefaultUserIcon for a default.
@hide 
*/
getUserIcon : function(  ) {},

/**Returns the maximum number of users that can be created on this device. A return value
 of 1 means that it is a single user device.
@hide 
@return {Number} a value greater than or equal to 1
*/
getMaxSupportedUsers : function(  ) {},

/**Returns true if the user switcher should be shown, this will be if device supports multi-user
 and there are at least 2 users available that are not managed profiles.
@hide 
@return {Boolean} true if user switcher should be shown.
*/
isUserSwitcherEnabled : function(  ) {},

/**
@hide 
*/
isDeviceInDemoMode : function(  ) {},

/**Returns a serial number on this device for a given userHandle. User handles can be recycled
 when deleting and creating users, but serial numbers are not reused until the device is wiped.
@param {Number} userHandle
@return {Number} a serial number associated with that user, or -1 if the userHandle is not valid.
@hide 
*/
getUserSerialNumber : function(  ) {},

/**Returns a userHandle on this device for a given user serial number. User handles can be
 recycled when deleting and creating users, but serial numbers are not reused until the device
 is wiped.
@param {Number} userSerialNumber
@return {Number} the userHandle associated with that user serial number, or -1 if the serial number
 is not valid.
@hide 
*/
getUserHandle : function(  ) {},

/**Returns a {@link android.os.Bundle} containing any saved application restrictions for this user, for the
 given package name. Only an application with this package name can call this method.

 <p>The returned {@link android.os.Bundle} consists of key-value pairs, as defined by the application,
 where the types of values may be:
 <ul>
 <li>{@code boolean}
 <li>{@code int}
 <li>{@code String} or {@code String[]}
 <li>From {@link android.os.Build.VERSION_CODES#M}, {@code Bundle} or {@code Bundle[]}
 </ul>

 <p>NOTE: The method performs disk I/O and shouldn't be called on the main thread
@param {String} packageName the package name of the calling application
@return {Object {android.os.Bundle}} a {@link Bundle} with the restrictions for that package, or an empty {@link Bundle}
 if there are no saved restrictions.
@see #KEY_RESTRICTIONS_PENDING
*/
getApplicationRestrictions : function(  ) {},

/**
@hide 
*/
getApplicationRestrictions : function(  ) {},

/**
@hide 
*/
setApplicationRestrictions : function(  ) {},

/**Sets a new challenge PIN for restrictions. This is only for use by pre-installed
 apps and requires the MANAGE_USERS permission.
@param {String} newPin the PIN to use for challenge dialogs.
@return {Boolean} Returns true if the challenge PIN was set successfully.
@deprecated The restrictions PIN functionality is no longer provided by the system.
 This method is preserved for backwards compatibility reasons and always returns false.
*/
setRestrictionsChallenge : function(  ) {},

/**
@hide Set restrictions that should apply to any future guest user that's created.
*/
setDefaultGuestRestrictions : function(  ) {},

/**
@hide Gets the default guest restrictions.
*/
getDefaultGuestRestrictions : function(  ) {},

/**Returns creation time of the user or of a managed profile associated with the calling user.
@param {Object {UserHandle}} userHandle user handle of the user or a managed profile associated with the
                   calling user.
@return {Number} creation time in milliseconds since Epoch time.
*/
getUserCreationTime : function(  ) {},

/**
@param {String} accountName The account name to check for
@param {String} accountType The account type of the account to check for
@param accountType The account type of the account to check for
@return {Boolean} whether the seed account was found
*/
someUserHasSeedAccount : function(  ) {},


};