/**@class android.app.NotificationManager
@extends java.lang.Object

 Class to notify the user of events that happen.  This is how you tell
 the user that something has happened in the background. {@more}

 Notifications can take different forms:
 <ul>
      <li>A persistent icon that goes in the status bar and is accessible
          through the launcher, (when the user selects it, a designated Intent
          can be launched),</li>
      <li>Turning on or flashing LEDs on the device, or</li>
      <li>Alerting the user by flashing the backlight, playing a sound,
          or vibrating.</li>
 </ul>

 <p>
 Each of the notify methods takes an int id parameter and optionally a
 {@link String} tag parameter, which may be {@code null}.  These parameters
 are used to form a pair (tag, id), or ({@code null}, id) if tag is
 unspecified.  This pair identifies this notification from your app to the
 system, so that pair should be unique within your app.  If you call one
 of the notify methods with a (tag, id) pair that is currently active and
 a new set of notification parameters, it will be updated.  For example,
 if you pass a new status bar icon, the old icon in the status bar will
 be replaced with the new one.  This is also the same tag and id you pass
 to the {@link #cancel}(int) or {@link #cancel(String, int)} method to clear
 this notification.

 <div class="special reference">
 <h3>Developer Guides</h3>
 <p>For a guide to creating notifications, read the
 <a href="{@docRoot}guide/topics/ui/notifiers/notifications.html">Status Bar Notifications</a>
 developer guide.</p>
 </div>

 @see android.app.Notification
*/
var NotificationManager = {

/** Intent that is broadcast when an application is blocked or unblocked.

 This broadcast is only sent to the app whose block state has changed.

 Input: nothing
 Output: {@link #EXTRA_BLOCKED_STATE}
*/
ACTION_APP_BLOCK_STATE_CHANGED : "android.app.action.APP_BLOCK_STATE_CHANGED",
/** Intent that is broadcast when a {@link android.app.NotificationChannel} is blocked
 (when {@link android.app.NotificationChannel#getImportance()} is {@link #IMPORTANCE_NONE}) or unblocked
 (when {@link android.app.NotificationChannel#getImportance()} is anything other than
 {@link #IMPORTANCE_NONE}).

 This broadcast is only sent to the app that owns the channel that has changed.

 Input: nothing
 Output: {@link #EXTRA_NOTIFICATION_CHANNEL_ID}
 Output: {@link #EXTRA_BLOCKED_STATE}
*/
ACTION_NOTIFICATION_CHANNEL_BLOCK_STATE_CHANGED : "android.app.action.NOTIFICATION_CHANNEL_BLOCK_STATE_CHANGED",
/** Extra for {@link #ACTION_NOTIFICATION_CHANNEL_BLOCK_STATE_CHANGED} containing the id of the
 {@link android.app.NotificationChannel} which has a new blocked state.

 The value will be the {@link android.app.NotificationChannel#getId()} of the channel.
*/
EXTRA_NOTIFICATION_CHANNEL_ID : "android.app.extra.NOTIFICATION_CHANNEL_ID",
/** Extra for {@link #ACTION_NOTIFICATION_CHANNEL_GROUP_BLOCK_STATE_CHANGED} containing the id
 of the {@link android.app.NotificationChannelGroup} which has a new blocked state.

 The value will be the {@link android.app.NotificationChannelGroup#getId()} of the group.
*/
EXTRA_NOTIFICATION_CHANNEL_GROUP_ID : "android.app.extra.NOTIFICATION_CHANNEL_GROUP_ID",
/** Extra for {@link #ACTION_NOTIFICATION_CHANNEL_BLOCK_STATE_CHANGED} or
 {@link #ACTION_NOTIFICATION_CHANNEL_GROUP_BLOCK_STATE_CHANGED} containing the new blocked
 state as a boolean.

 The value will be {@code true} if this channel or group is now blocked and {@code false} if
 this channel or group is now unblocked.
*/
EXTRA_BLOCKED_STATE : "android.app.extra.BLOCKED_STATE",
/** Intent that is broadcast when a {@link android.app.NotificationChannelGroup} is
 {@link android.app.NotificationChannelGroup#isBlocked() blocked} or unblocked.

 This broadcast is only sent to the app that owns the channel group that has changed.

 Input: nothing
 Output: {@link #EXTRA_NOTIFICATION_CHANNEL_GROUP_ID}
 Output: {@link #EXTRA_BLOCKED_STATE}
*/
ACTION_NOTIFICATION_CHANNEL_GROUP_BLOCK_STATE_CHANGED : "android.app.action.NOTIFICATION_CHANNEL_GROUP_BLOCK_STATE_CHANGED",
/** Intent that is broadcast when the state of {@link #getEffectsSuppressor}() changes.
 This broadcast is only sent to registered receivers.

 @hide
*/
ACTION_EFFECTS_SUPPRESSOR_CHANGED : "android.os.action.ACTION_EFFECTS_SUPPRESSOR_CHANGED",
/** Intent that is broadcast when the state of {@link #isNotificationPolicyAccessGranted}()
 changes.

 This broadcast is only sent to registered receivers, and only to the apps that have changed.
*/
ACTION_NOTIFICATION_POLICY_ACCESS_GRANTED_CHANGED : "android.app.action.NOTIFICATION_POLICY_ACCESS_GRANTED_CHANGED",
/** Intent that is broadcast when the state of getNotificationPolicy() changes.
 This broadcast is only sent to registered receivers.
*/
ACTION_NOTIFICATION_POLICY_CHANGED : "android.app.action.NOTIFICATION_POLICY_CHANGED",
/** Intent that is broadcast when the state of getCurrentInterruptionFilter() changes.
 This broadcast is only sent to registered receivers.
*/
ACTION_INTERRUPTION_FILTER_CHANGED : "android.app.action.INTERRUPTION_FILTER_CHANGED",
/** Intent that is broadcast when the state of getCurrentInterruptionFilter() changes.
 @hide
*/
ACTION_INTERRUPTION_FILTER_CHANGED_INTERNAL : "android.app.action.INTERRUPTION_FILTER_CHANGED_INTERNAL",
/** {@link #getCurrentInterruptionFilter() Interruption filter} constant -
     Normal interruption filter - no notifications are suppressed.
*/
INTERRUPTION_FILTER_ALL : "1",
/** {@link #getCurrentInterruptionFilter() Interruption filter} constant -
     Priority interruption filter - all notifications are suppressed except those that match
     the priority criteria. Some audio streams are muted. See
     {@link android.app.NotificationManager.Policy#priorityCallSenders}, {@link android.app.NotificationManager.Policy#priorityCategories},
     {@link android.app.NotificationManager.Policy#priorityMessageSenders} to define or query this criteria. Users can
     additionally specify packages that can bypass this interruption filter.
*/
INTERRUPTION_FILTER_PRIORITY : "2",
/** {@link #getCurrentInterruptionFilter() Interruption filter} constant -
     No interruptions filter - all notifications are suppressed and all audio streams (except
     those used for phone calls) and vibrations are muted.
*/
INTERRUPTION_FILTER_NONE : "3",
/** {@link #getCurrentInterruptionFilter() Interruption filter} constant -
     Alarms only interruption filter - all notifications except those of category
     {@link android.app.Notification#CATEGORY_ALARM} are suppressed. Some audio streams are muted.
*/
INTERRUPTION_FILTER_ALARMS : "4",
/**{@link #getCurrentInterruptionFilter() Interruption filter} constant - returned when
 the value is unavailable for any reason.
*/
INTERRUPTION_FILTER_UNKNOWN : "0",
/** Activity Action: Launch an Automatic Zen Rule configuration screen
 <p>
 Input: Optionally, {@link #EXTRA_AUTOMATIC_RULE_ID}, if the configuration screen for an
 existing rule should be displayed. If the rule id is missing or null, apps should display
 a configuration screen where users can create a new instance of the rule.
 <p>
 Output: Nothing
 <p>
     You can have multiple activities handling this intent, if you support multiple
     {@link android.app.AutomaticZenRule rules}. In order for the system to properly display all of your
     rule types so that users can create new instances or configure existing ones, you need
     to add some extra metadata ({@link #META_DATA_AUTOMATIC_RULE_TYPE})
     to your activity tag in your manifest. If you'd like to limit the number of rules a user
     can create from this flow, you can additionally optionally include
     {@link #META_DATA_RULE_INSTANCE_LIMIT}.

     For example,
     &lt;meta-data
         android:name="android.app.zen.automatic.ruleType"
         android:value="@string/my_condition_rule">
     &lt;/meta-data>
     &lt;meta-data
         android:name="android.app.zen.automatic.ruleInstanceLimit"
         android:value="1">
     &lt;/meta-data>
 </p>
 </p>

 @see {@link #addAutomaticZenRule}(AutomaticZenRule)
*/
ACTION_AUTOMATIC_ZEN_RULE : "android.app.action.AUTOMATIC_ZEN_RULE",
/** Used as an optional string extra on {@link #ACTION_AUTOMATIC_ZEN_RULE} intents. If
 provided, contains the id of the {@link android.app.AutomaticZenRule} (as returned from
 {@link android.app.NotificationManager#addAutomaticZenRule(AutomaticZenRule)}) for which configuration
 settings should be displayed.
*/
EXTRA_AUTOMATIC_RULE_ID : "android.app.extra.AUTOMATIC_RULE_ID",
/** A required {@code meta-data} tag for activities that handle
 {@link #ACTION_AUTOMATIC_ZEN_RULE}.

 This tag should contain a localized name of the type of the zen rule provided by the
 activity.
*/
META_DATA_AUTOMATIC_RULE_TYPE : "android.service.zen.automatic.ruleType",
/** An optional {@code meta-data} tag for activities that handle
 {@link #ACTION_AUTOMATIC_ZEN_RULE}.

 This tag should contain the maximum number of rule instances that
 can be created for this rule type. Omit or enter a value <= 0 to allow unlimited instances.
*/
META_DATA_RULE_INSTANCE_LIMIT : "android.service.zen.automatic.ruleInstanceLimit",
/**Value signifying that the user has not expressed a per-app visibility override value.
 @hide */
VISIBILITY_NO_OVERRIDE : "-1000",
/** Value signifying that the user has not expressed an importance.

 This value is for persisting preferences, and should never be associated with
 an actual notification.
*/
IMPORTANCE_UNSPECIFIED : "-1000",
/** A notification with no importance: does not show in the shade.
*/
IMPORTANCE_NONE : "0",
/** Min notification importance: only shows in the shade, below the fold.  This should
 not be used with {@link Service#startForeground(int, android.app.Notification) Service.startForeground}
 since a foreground service is supposed to be something the user cares about so it does
 not make semantic sense to mark its notification as minimum importance.  If you do this
 as of Android version {@link android.os.Build.VERSION_CODES#O}, the system will show
 a higher-priority notification about your app running in the background.
*/
IMPORTANCE_MIN : "1",
/** Low notification importance: Shows in the shade, and potentially in the status bar
 (see {@link #shouldHideSilentStatusBarIcons}()), but is not audibly intrusive.
*/
IMPORTANCE_LOW : "2",
/** Default notification importance: shows everywhere, makes noise, but does not visually
 intrude.
*/
IMPORTANCE_DEFAULT : "3",
/** Higher notification importance: shows everywhere, makes noise and peeks. May use full screen
 intents.
*/
IMPORTANCE_HIGH : "4",
/** Unused.
*/
IMPORTANCE_MAX : "5",
/**
@hide 
*/
getService : function(  ) {},

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

/**Post a notification to be shown in the status bar. If a notification with
 the same id has already been posted by your application and has not yet been canceled, it
 will be replaced by the updated information.
@param {Number} id An identifier for this notification unique within your
        application.
@param {Object {Notification}} notification A {@link Notification} object describing what to show the user. Must not
        be null.
*/
notify : function(  ) {},

/**Posts a notification to be shown in the status bar. If a notification with
 the same tag and id has already been posted by your application and has not yet been
 canceled, it will be replaced by the updated information.

 All {@link android.service.notification.NotificationListenerService listener services} will
 be granted {@link Intent#FLAG_GRANT_READ_URI_PERMISSION} access to any {@link Uri uris}
 provided on this notification or the
 {@link android.app.NotificationChannel} this notification is posted to using
 {@link Context#grantUriPermission(String, Uri, int)}. Permission will be revoked when the
 notification is canceled, or you can revoke permissions with
 {@link Context#revokeUriPermission(Uri, int)}.
@param {String} tag A string identifier for this notification.  May be {@code null}.
@param {Number} id An identifier for this notification.  The pair (tag, id) must be unique
        within your application.
@param {Object {Notification}} notification A {@link Notification} object describing what to
        show the user. Must not be null.
*/
notify : function(  ) {},

/**Posts a notification as a specified package to be shown in the status bar. If a notification
 with the same tag and id has already been posted for that package and has not yet been
 canceled, it will be replaced by the updated information.

 All {@link android.service.notification.NotificationListenerService listener services} will
 be granted {@link Intent#FLAG_GRANT_READ_URI_PERMISSION} access to any {@link Uri uris}
 provided on this notification or the
 {@link android.app.NotificationChannel} this notification is posted to using
 {@link Context#grantUriPermission(String, Uri, int)}. Permission will be revoked when the
 notification is canceled, or you can revoke permissions with
 {@link Context#revokeUriPermission(Uri, int)}.
@param {String} targetPackage The package to post the notification as. The package must have granted
                      you access to post notifications on their behalf with
                      {@link #setNotificationDelegate(String)}.
@param {String} tag A string identifier for this notification.  May be {@code null}.
@param {Number} id An identifier for this notification.  The pair (tag, id) must be unique
        within your application.
@param {Object {Notification}} notification A {@link Notification} object describing what to
        show the user. Must not be null.
*/
notifyAsPackage : function(  ) {},

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

/**Cancel a previously shown notification.  If it's transient, the view
 will be hidden.  If it's persistent, it will be removed from the status
 bar.
*/
cancel : function(  ) {},

/**Cancel a previously shown notification.  If it's transient, the view
 will be hidden.  If it's persistent, it will be removed from the status
 bar.
*/
cancel : function(  ) {},

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

/**Cancel all previously shown notifications. See {@link #cancel} for the
 detailed behavior.
*/
cancelAll : function(  ) {},

/**Allows a package to post notifications on your behalf using
 {@link #notifyAsPackage(String, String, int, android.app.Notification)}.

 This can be used to allow persistent processes to post notifications based on messages
 received on your behalf from the cloud, without your process having to wake up.

 You can check if you have an allowed delegate with {@link #getNotificationDelegate}() and
 revoke your delegate by passing null to this method.
@param {String} delegate Package name of the app which can send notifications on your behalf.
*/
setNotificationDelegate : function(  ) {},

/**Returns the {@link #setNotificationDelegate(String) delegate} that can post notifications on
 your behalf, if there currently is one.
*/
getNotificationDelegate : function(  ) {},

/**Returns whether you are allowed to post notifications on behalf of a given package, with
 {@link #notifyAsPackage(String, String, int, android.app.Notification)}.

 See {@link #setNotificationDelegate}(String).
*/
canNotifyAsPackage : function(  ) {},

/**Creates a group container for {@link android.app.NotificationChannel} objects.

 This can be used to rename an existing group.
 <p>
     Group information is only used for presentation, not for behavior. Groups are optional
     for channels, and you can have a mix of channels that belong to groups and channels
     that do not.
 </p>
 <p>
     For example, if your application supports multiple accounts, and those accounts will
     have similar channels, you can create a group for each account with account specific
     labels instead of appending account information to each channel's label.
 </p>
@param {Object {NotificationChannelGroup}} group The group to create
*/
createNotificationChannelGroup : function(  ) {},

/**Creates multiple notification channel groups.
@param {Object {java.util.List}} groups The list of groups to create
*/
createNotificationChannelGroups : function(  ) {},

/**Creates a notification channel that notifications can be posted to.

 This can also be used to restore a deleted channel and to update an existing channel's
 name, description, group, and/or importance.

 <p>The name and description should only be changed if the locale changes
 or in response to the user renaming this channel. For example, if a user has a channel
 named 'John Doe' that represents messages from a 'John Doe', and 'John Doe' changes his name
 to 'John Smith,' the channel can be renamed to match.

 <p>The importance of an existing channel will only be changed if the new importance is lower
 than the current value and the user has not altered any settings on this channel.

 <p>The group an existing channel will only be changed if the channel does not already
 belong to a group.

 All other fields are ignored for channels that already exist.
@param {Object {NotificationChannel}} channel  the channel to create.  Note that the created channel may differ from this
                 value. If the provided channel is malformed, a RemoteException will be
                 thrown.
*/
createNotificationChannel : function(  ) {},

/**Creates multiple notification channels that different notifications can be posted to. See
 {@link #createNotificationChannel}(NotificationChannel).
@param {Object {java.util.List}} channels the list of channels to attempt to create.
*/
createNotificationChannels : function(  ) {},

/**Returns the notification channel settings for a given channel id.

 <p>The channel must belong to your package, or to a package you are an approved notification
 delegate for (see {@link #canNotifyAsPackage}(String)), or it will not be returned. To query
 a channel as a notification delegate, call this method from a context created for that
 package (see {@link Context#createPackageContext(String, int)}).</p>
*/
getNotificationChannel : function(  ) {},

/**Returns all notification channels belonging to the calling package.

 <p>Approved notification delegates (see {@link #canNotifyAsPackage}(String)) can query
 notification channels belonging to packages they are the delegate for. To do so, call this
 method from a context created for that package (see
 {@link Context#createPackageContext(String, int)}).</p>
*/
getNotificationChannels : function(  ) {},

/**Deletes the given notification channel.

 <p>If you {@link #createNotificationChannel(NotificationChannel) create} a new channel with
 this same id, the deleted channel will be un-deleted with all of the same settings it
 had before it was deleted.
*/
deleteNotificationChannel : function(  ) {},

/**Returns the notification channel group settings for a given channel group id.

 The channel group must belong to your package, or null will be returned.
*/
getNotificationChannelGroup : function(  ) {},

/**Returns all notification channel groups belonging to the calling app.
*/
getNotificationChannelGroups : function(  ) {},

/**Deletes the given notification channel group, and all notification channels that
 belong to it.
*/
deleteNotificationChannelGroup : function(  ) {},

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

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

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

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

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

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

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

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

/**Returns AutomaticZenRules owned by the caller.

 <p>
 Throws a SecurityException if policy access is granted to this package.
 See {@link #isNotificationPolicyAccessGranted}.
*/
getAutomaticZenRules : function(  ) {},

/**Returns the AutomaticZenRule with the given id, if it exists and the caller has access.

 <p>
 Throws a SecurityException if policy access is granted to this package.
 See {@link #isNotificationPolicyAccessGranted}.

 <p>
 Returns null if there are no zen rules that match the given id, or if the calling package
 doesn't own the matching rule. See {@link android.app.AutomaticZenRule#getOwner}.
*/
getAutomaticZenRule : function(  ) {},

/**Creates the given zen rule.

 <p>
 Throws a SecurityException if policy access is granted to this package.
 See {@link #isNotificationPolicyAccessGranted}.
@param {Object {AutomaticZenRule}} automaticZenRule the rule to create.
@return {String} The id of the newly created rule; null if the rule could not be created.
*/
addAutomaticZenRule : function(  ) {},

/**Updates the given zen rule.

 <p>
 Throws a SecurityException if policy access is granted to this package.
 See {@link #isNotificationPolicyAccessGranted}.

 <p>
 Callers can only update rules that they own. See {@link android.app.AutomaticZenRule#getOwner}.
@param {String} id The id of the rule to update
@param {Object {AutomaticZenRule}} automaticZenRule the rule to update.
@return {Boolean} Whether the rule was successfully updated.
*/
updateAutomaticZenRule : function(  ) {},

/**Informs the notification manager that the state of an {@link android.app.AutomaticZenRule} has changed.
 Use this method to put the system into Do Not Disturb mode or request that it exits Do Not
 Disturb mode. The calling app must own the provided {@link android.app.AutomaticZenRule}.
 <p>
     This method can be used in conjunction with or as a replacement to
     {@link android.service.notification.ConditionProviderService#notifyCondition(Condition)}.
 </p>
@param {String} id The id of the rule whose state should change
@param {Object {Condition}} condition The new state of this rule
*/
setAutomaticZenRuleState : function(  ) {},

/**Deletes the automatic zen rule with the given id.

 <p>
 Throws a SecurityException if policy access is granted to this package.
 See {@link #isNotificationPolicyAccessGranted}.

 <p>
 Callers can only delete rules that they own. See {@link android.app.AutomaticZenRule#getOwner}.
@param {String} id the id of the rule to delete.
@return {Boolean} Whether the rule was successfully deleted.
*/
removeAutomaticZenRule : function(  ) {},

/**Deletes all automatic zen rules owned by the given package.
@hide 
*/
removeAutomaticZenRules : function(  ) {},

/**Returns the user specified importance for notifications from the calling
 package.
*/
getImportance : function(  ) {},

/**Returns whether notifications from the calling package are blocked.
*/
areNotificationsEnabled : function(  ) {},

/**Sets whether notifications posted by this app can appear outside of the
 notification shade, floating over other apps' content.

 <p>This value will be ignored for notifications that are posted to channels that do not
 allow bubbles ({@link android.app.NotificationChannel#canBubble()}.
@see Notification#getBubbleMetadata()
*/
areBubblesAllowed : function(  ) {},

/**Returns whether notifications from this package are temporarily hidden. This
 could be done because the package was marked as distracting to the user via
 {@code PackageManager#setDistractingPackageRestrictions(String[], int)} or because the
 package is {@code PackageManager#setPackagesSuspended(String[], boolean, PersistableBundle,
 PersistableBundle, SuspendDialogInfo) suspended}.
*/
areNotificationsPaused : function(  ) {},

/**Checks the ability to modify notification do not disturb policy for the calling package.

 <p>
 Returns true if the calling package can modify notification policy.

 <p>
 Apps can request policy access by sending the user to the activity that matches the system
 intent action {@link android.provider.Settings#ACTION_NOTIFICATION_POLICY_ACCESS_SETTINGS}.

 <p>
 Use {@link #ACTION_NOTIFICATION_POLICY_ACCESS_GRANTED_CHANGED} to listen for
 user grant or denial of this access.
*/
isNotificationPolicyAccessGranted : function(  ) {},

/**Checks whether the user has approved a given
 {@link android.service.notification.NotificationListenerService}.

 <p>
 The listener service must belong to the calling app.

 <p>
 Apps can request notification listener access by sending the user to the activity that
 matches the system intent action
 {@link android.provider.Settings#ACTION_NOTIFICATION_LISTENER_SETTINGS}.
*/
isNotificationListenerAccessGranted : function(  ) {},

/**Checks whether the user has approved a given
 {@link android.service.notification.NotificationAssistantService}.

 <p>
 The assistant service must belong to the calling app.

 <p>
 Apps can request notification assistant access by sending the user to the activity that
 matches the system intent action
 TODO: STOPSHIP: Add correct intent
 {@link android.provider.Settings#ACTION_MANAGE_DEFAULT_APPS_SETTINGS}.
@hide 
*/
isNotificationAssistantAccessGranted : function(  ) {},

/**Returns whether the user wants silent notifications (see {@link #IMPORTANCE_LOW} to appear
 in the status bar.

 <p>Only available for {@link #isNotificationListenerAccessGranted(ComponentName) notification
 listeners}.
*/
shouldHideSilentStatusBarIcons : function(  ) {},

/**Returns the list of {@link android.service.notification.Adjustment adjustment keys} that can
 be modified by the current {@link android.service.notification.NotificationAssistantService}.

 <p>Only callable by the current
 {@link android.service.notification.NotificationAssistantService}.
 See {@link #isNotificationAssistantAccessGranted}(ComponentName)</p>
@hide 
*/
getAllowedAssistantAdjustments : function(  ) {},

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

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

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

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

/**Gets the current user-specified default notification policy.

 <p>
*/
getNotificationPolicy : function(  ) {},

/**Sets the current notification policy.

 <p>
 Only available if policy access is granted to this package.
 See {@link #isNotificationPolicyAccessGranted}.
@param {Object {NotificationManager.Policy}} policy The new desired policy.
*/
setNotificationPolicy : function(  ) {},

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

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

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

/**Grants/revokes Notification Assistant access to {@code assistant} for current user.
 To grant access for a particular user, obtain this service by using the {@link Context}
 provided by {@link Context#createPackageContextAsUser}
@param {Object {ComponentName}} assistant Name of component to grant/revoke access or {@code null} to revoke access to
                  current assistant
@param {Boolean} granted Grant/revoke access
@hide 
*/
setNotificationAssistantAccessGranted : function(  ) {},

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

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

/**Recover a list of active notifications: ones that have been posted by the calling app that
 have not yet been dismissed by the user or {@link #cancel(String, int)}ed by the app.

 <p><Each notification is embedded in a {@link StatusBarNotification} object, including the
 original <code>tag</code> and <code>id</code> supplied to
 {@link #notify(String, int, android.app.Notification) notify()}
 (via {@link StatusBarNotification#getTag() getTag()} and
 {@link StatusBarNotification#getId() getId()}) as well as a copy of the original
 {@link android.app.Notification} object (via {@link StatusBarNotification#getNotification()}).
 </p>
 <p>From {@link Build.VERSION_CODES#Q}, will also return notifications you've posted as an
 app's notification delegate via
 {@link android.app.NotificationManager#notifyAsPackage(String, String, int, android.app.Notification)}.
 </p>
@return {Object {android.service.notification.StatusBarNotification}} An array of {@link StatusBarNotification}.
*/
getActiveNotifications : function(  ) {},

/**Gets the current notification interruption filter.
 <p>
 The interruption filter defines which notifications are allowed to
 interrupt the user (e.g. via sound &amp; vibration) and is applied
 globally.
*/
getCurrentInterruptionFilter : function(  ) {},

/**Sets the current notification interruption filter.
 <p>
 The interruption filter defines which notifications are allowed to
 interrupt the user (e.g. via sound &amp; vibration) and is applied
 globally.
 <p>
 Only available if policy access is granted to this package. See
 {@link #isNotificationPolicyAccessGranted}.
*/
setInterruptionFilter : function(  ) {},

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

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


};