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

 Manages users and user details on a multi-user system.
*/
var UserManager = {

/** 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/>Key for user restrictions.
 <p/>Type: Boolean
 @see #setUserRestrictions(Bundle)
 @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 #setUserRestrictions(Bundle)
 @see #getUserRestrictions()
*/
DISALLOW_CONFIG_WIFI : "no_config_wifi",
/** Specifies if a user is disallowed from installing applications.
 The default value is <code>false</code>.

 <p/>Key for user restrictions.
 <p/>Type: Boolean
 @see #setUserRestrictions(Bundle)
 @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 #setUserRestrictions(Bundle)
 @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 #setUserRestrictions(Bundle)
 @see #getUserRestrictions()
*/
DISALLOW_SHARE_LOCATION : "no_share_location",
/** Specifies if a user is disallowed from enabling the
 "Unknown Sources" setting, that allows installation of apps from unknown sources.
 The default value is <code>false</code>.

 <p/>Key for user restrictions.
 <p/>Type: Boolean
 @see #setUserRestrictions(Bundle)
 @see #getUserRestrictions()
*/
DISALLOW_INSTALL_UNKNOWN_SOURCES : "no_install_unknown_sources",
/** 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 has no effect in a managed profile.

 <p/>Key for user restrictions.
 <p/>Type: Boolean
 @see #setUserRestrictions(Bundle)
 @see #getUserRestrictions()
*/
DISALLOW_CONFIG_BLUETOOTH : "no_config_bluetooth",
/** 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 #setUserRestrictions(Bundle)
 @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 #setUserRestrictions(Bundle)
 @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 #setUserRestrictions(Bundle)
 @see #getUserRestrictions()
*/
DISALLOW_REMOVE_USER : "no_remove_user",
/** Specifies if a user is disallowed from enabling or
 accessing debugging features. The default value is <code>false</code>.

 <p/>Key for user restrictions.
 <p/>Type: Boolean
 @see #setUserRestrictions(Bundle)
 @see #getUserRestrictions()
*/
DISALLOW_DEBUGGING_FEATURES : "no_debugging_features",
/** Specifies if a user is disallowed from configuring VPN.
 The default value is <code>false</code>.
 This restriction has an effect in a managed profile only from
 {@link android.os.Build.VERSION_CODES#M}

 <p/>Key for user restrictions.
 <p/>Type: Boolean
 @see #setUserRestrictions(Bundle)
 @see #getUserRestrictions()
*/
DISALLOW_CONFIG_VPN : "no_config_vpn",
/** 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/>Key for user restrictions.
 <p/>Type: Boolean
 @see #setUserRestrictions(Bundle)
 @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 #setUserRestrictions(Bundle)
 @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 #setUserRestrictions(Bundle)
 @see #getUserRestrictions()
*/
DISALLOW_FACTORY_RESET : "no_factory_reset",
/** Specifies if a user is disallowed from adding new users and
 profiles. 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 #setUserRestrictions(Bundle)
 @see #getUserRestrictions()
*/
DISALLOW_ADD_USER : "no_add_user",
/** Specifies if a user is disallowed from disabling application
 verification. The default value is <code>false</code>.

 <p/>Key for user restrictions.
 <p/>Type: Boolean
 @see #setUserRestrictions(Bundle)
 @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 #setUserRestrictions(Bundle)
 @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 #setUserRestrictions(Bundle)
 @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/>Key for user restrictions.
 <p/>Type: Boolean
 @see #setUserRestrictions(Bundle)
 @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 #setUserRestrictions(Bundle)
 @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 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 #setUserRestrictions(Bundle)
 @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 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 #setUserRestrictions(Bundle)
 @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 since call intents are normally
 forwarded to the primary user.

 <p/>Key for user restrictions.
 <p/>Type: Boolean
 @see #setUserRestrictions(Bundle)
 @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 #setUserRestrictions(Bundle)
 @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 #setUserRestrictions(Bundle)
 @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>

 <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 #setUserRestrictions(Bundle)
 @see #getUserRestrictions()
*/
DISALLOW_CREATE_WINDOWS : "no_create_windows",
/** Specifies if what is copied in the clipboard of this profile can
 be pasted in related profiles. Does not restrict if the clipboard of related profiles can be
 pasted in this profile.
 The default value is <code>false</code>.

 <p/>Key for user restrictions.
 <p/>Type: Boolean
 @see #setUserRestrictions(Bundle)
 @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 #setUserRestrictions(Bundle)
 @see #getUserRestrictions()
*/
DISALLOW_OUTGOING_BEAM : "no_outgoing_beam",
/** Hidden user restriction to disallow access to wallpaper manager APIs. This user restriction
 is always set for managed profiles.
 @hide
 @see #setUserRestrictions(Bundle)
 @see #getUserRestrictions()
*/
DISALLOW_WALLPAPER : "no_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 #setUserRestrictions(Bundle)
 @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 #setUserRestrictions(Bundle)
 @see #getUserRestrictions()
 @hide
*/
DISALLOW_RECORD_AUDIO : "no_record_audio",
/** 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 #setUserRestrictions(Bundle)
 @see #getUserRestrictions()
*/
ALLOW_PARENT_PROFILE_APP_LINKING : "allow_parent_profile_app_linking",
/** 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",
/**@hide */
PIN_VERIFICATION_FAILED_INCORRECT : "-3",
/**@hide */
PIN_VERIFICATION_FAILED_NOT_SET : "-2",
/**@hide */
PIN_VERIFICATION_SUCCESS : "-1",
/**
@hide 
*/
get : function(  ) {},

/**Returns whether the system supports multiple users.
@return {Boolean} true if multiple users can be created by user, false if it is a single user device.
@hide 
*/
supportsMultipleUsers : 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
 MANAGE_USERS permission.
@return {String} the user name
*/
getUserName : 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 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(  ) {},

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

/**Used to check if the user making this call is linked to another user. Linked users may have
 a reduced number of available apps, app restrictions and account restrictions.
@return {Boolean} whether the user making this call is a linked user
@hide 
*/
isLinkedUser : function(  ) {},

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

/**Checks if the calling app is running in a managed profile.
 Requires {@link android.Manifest.permission#MANAGE_USERS} permission.
@return {Boolean} whether the caller is in a managed profile.
@hide 
*/
isManagedProfile : 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.
@param {Object {UserHandle}} user The user to retrieve the running state for.
*/
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).
@param {Object {UserHandle}} user The user to retrieve the running state for.
*/
isUserRunningOrStopping : 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(  ) {},

/**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(  ) {},

/**Sets all the user-wide restrictions for this user.
 Requires the MANAGE_USERS permission.
@param {Object {Bundle}} restrictions the Bundle containing all the restrictions.
@deprecated use {@link android.app.admin.DevicePolicyManager#addUserRestriction(
 android.content.ComponentName, String)} or
 {@link android.app.admin.DevicePolicyManager#clearUserRestriction(
 android.content.ComponentName, String)} instead.
*/
setUserRestrictions : function(  ) {},

/**Sets all the user-wide restrictions for the specified user.
 Requires the MANAGE_USERS permission.
@param {Object {Bundle}} restrictions the Bundle containing all the restrictions.
@param {Object {UserHandle}} userHandle the UserHandle of the user for whom to set the restrictions.
@deprecated use {@link android.app.admin.DevicePolicyManager#addUserRestriction(
 android.content.ComponentName, String)} or
 {@link android.app.admin.DevicePolicyManager#clearUserRestriction(
 android.content.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(  ) {},

/**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.
 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 secondary user with the specified name and options and configures it with default
 restrictions.
 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 
*/
createSecondaryUser : 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 use.
@param userHandle new user will be a profile of this use.
@return {Object {android.content.pm.UserInfo}} the UserInfo object for the created user, or null if the user could not be created.
@hide 
*/
createProfileForUser : function(  ) {},

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

/**Sets the user as enabled, if such an user exists.
 Requires {@link android.Manifest.permission#MANAGE_USERS} permission.
 Note that the default is true, it's only that managed profiles might not be enabled.
@param {Number} userHandle the id of the profile to enable
@hide 
*/
setUserEnabled : function(  ) {},

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

/**Returns information for all users on this device.
 Requires {@link android.Manifest.permission#MANAGE_USERS} permission.
@return {Object {java.util.List}} the list of users that were created.
@hide 
*/
getUsers : 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.
@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(  ) {},

/**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 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(  ) {},

/**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 bading
 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 bading
 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 not provided, 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 not provided,
         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(  ) {},

/**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(  ) {},

/**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(  ) {},

/**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 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 there
 are multiple users that aren't managed profiles.
@hide 
@return {Boolean} true if user switcher should be shown.
*/
isUserSwitcherEnabled : 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 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.
@param {String} packageName the package name of the calling application
@return {Object {android.os.Bundle}} a Bundle with the restrictions as key/value pairs, or null if there are no
 saved restrictions. The values can be of type Boolean, String or String[], depending
 on the restriction type, as defined by the application.
*/
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 
*/
removeRestrictions : 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(  ) {},


};