Expo

Get Started
API Reference

Notifications

The expo-notifications provides an API to fetch push notification tokens and to present, schedule, receive and respond to notifications.

Features

  • 📣 schedule a one-off notification for a specific date, or some time from now,
  • 🔁 schedule a notification repeating in some time interval (or a calendar date match on iOS),
  • 1️⃣ get and set application badge icon number,
  • 📲 fetch a native device push token so you can send push notifications with FCM and APNS,
  • 😎 fetch an Expo push token so you can send push notifications with Expo,
  • 📬 listen to incoming notifications,
  • 👆 listen to interactions with notifications (tapping or dismissing),
  • 🎛 handle notifications when the app is in foreground,
  • 🔕 imperatively dismiss notifications from Notification Center/tray,
  • 🗂 create, update, delete Android notification channels,
  • 🎨 set custom icon and color for notifications on Android.

Push notifications Platform Compatibility

Android DeviceAndroid EmulatoriOS DeviceiOS SimulatorWeb
Pending

Local notifications Platform Compatibility

Android DeviceAndroid EmulatoriOS DeviceiOS SimulatorWeb
Pending

expo install expo-notifications

If you're installing this in a bare React Native app, you should also follow these additional installation instructions.

Open your app.json and add the following inside of the "expo" field:
{
  "expo": {
    ...
    "android": {
      ...
      "useNextNotificationsApi": true,
    }
  }
}
On Android, this module requires permission to subscribe to device boot. It's used to setup the scheduled notifications right after the device (re)starts. The RECEIVE_BOOT_COMPLETED permission is added automatically.

import * as Notifications from 'expo-notifications';
The following methods are exported by the expo-notifications module:

Types

Check out the Snack below to see Notifications in action, but be sure to use a physical device! Push notifications don't work on simulators/emulators.
import Constants from 'expo-constants';
import * as Notifications from 'expo-notifications';
import * as Permissions from 'expo-permissions';
import React, { useState, useEffect, useRef } from 'react';
import { Text, View, Button, Platform } from 'react-native';

Notifications.setNotificationHandler({
  handleNotification: async () => ({
    shouldShowAlert: true,
    shouldPlaySound: false,
    shouldSetBadge: false,
  }),
});

export default function App() {
  const [expoPushToken, setExpoPushToken] = useState('');
  const [notification, setNotification] = useState(false);
  const notificationListener = useRef();
  const responseListener = useRef();

  useEffect(() => {
    registerForPushNotificationsAsync().then(token => setExpoPushToken(token));

    notificationListener.current = Notifications.addNotificationReceivedListener(notification => {
      setNotification(notification);
    });

    responseListener.current = Notifications.addNotificationResponseReceivedListener(response => {
      console.log(response);
    });

    return () => {
      Notifications.removeNotificationSubscription(notificationListener);
      Notifications.removeNotificationSubscription(responseListener);
    };
  }, []);

  return (
    <View
      style={{
        flex: 1,
        alignItems: 'center',
        justifyContent: 'space-around',
      }}>
      <Text>Your expo push token: {expoPushToken}</Text>
      <View style={{ alignItems: 'center', justifyContent: 'center' }}>
        <Text>Title: {notification && notification.request.content.title} </Text>
        <Text>Body: {notification && notification.request.content.body}</Text>
        <Text>Data: {notification && JSON.stringify(notification.request.content.data)}</Text>
      </View>
      <Button
        title="Press to schedule a notification"
        onPress={async () => {
          await schedulePushNotification();
        }}
      />
    </View>
  );
}

async function schedulePushNotification() {
  await Notifications.scheduleNotificationAsync({
    content: {
      title: "You've got mail! 📬",
      body: 'Here is the notification body',
      data: { data: 'goes here' },
    },
    trigger: { seconds: 2 },
  });
}

async function registerForPushNotificationsAsync() {
  let token;
  if (Constants.isDevice) {
    const { status: existingStatus } = await Permissions.getAsync(Permissions.NOTIFICATIONS);
    let finalStatus = existingStatus;
    if (existingStatus !== 'granted') {
      const { status } = await Permissions.askAsync(Permissions.NOTIFICATIONS);
      finalStatus = status;
    }
    if (finalStatus !== 'granted') {
      alert('Failed to get push token for push notification!');
      return;
    }
    token = (await Notifications.getExpoPushTokenAsync()).data;
    console.log(token);
  } else {
    alert('Must use physical device for Push Notifications');
  }

  if (Platform.OS === 'android') {
    Notifications.setNotificationChannelAsync('default', {
      name: 'default',
      importance: Notifications.AndroidImportance.MAX,
      vibrationPattern: [0, 250, 250, 250],
      lightColor: '#FF231F7C',
    });
  }

  return token;
}
Note this demo will not work with remote notifications (sent via the Expo Notifications service) on Android when you run it from the snack, because app.json needs to contain the useNextNotificationsApi flag. Unfortunately, Snack doesn't support custom app.json files.

When sending a push notification, put an object conforming to the following type as data of the notification:
export interface FirebaseData {
  title?: string;
  message?: string;
  subtitle?: string;
  sound?: boolean | string;
  vibrate?: boolean | number[];
  priority?: AndroidNotificationPriority;
  badge?: number;
}

Returns an Expo token that can be used to send a push notification to this device using Expo push notifications service. Read more in the Push Notifications guide.
Note: For Expo backend to be able to send notifications to your app, you will need to provide it with push notification keys. This can be done using expo-cli (expo credentials:manager). Read more in the “Upload notifications credentials” guide.

This function accepts an optional object allowing you to pass in configuration, consisting of fields (all are optional, but some may have to be defined if configuration cannot be inferred):
  • experienceId (string) -- The ID of the experience to which the token should be attributed. Defaults to Constants.manifest.id exposed by expo-constants. You may need to define it in bare workflow, where expo-constants doesn't expose the manifest.
  • devicePushToken (DevicePushToken) -- The device push token with which to register at the backend. Defaults to a token fetched with getDevicePushTokenAsync().
  • applicationId (string) -- The ID of the application to which the token should be attributed. Defaults to Application.applicationId exposed by expo-application.
  • development (boolean) -- Makes sense only on iOS, where there are two push notification services: sandbox and production. This defines whether the push token is supposed to be used with the sandbox platform notification service. Defaults to Application.getIosPushNotificationServiceEnvironmentAsync() exposed by expo-application or false. Most probably you won't need to customize that. You may want to customize that if you don't want to install expo-application and still use the sandbox APNS.

Returns a Promise that resolves to an object with the following fields:
  • type (string) -- Always expo.
  • data (string) -- The push token as a string.

Fetching the Expo push token and uploading it to a server
import Constants from 'expo-constants';
import * as Notifications from 'expo-notifications';

export async function registerForPushNotificationsAsync(userId: string) {
  let experienceId = undefined;
  if (!Constants.manifest) {
    // Absence of the manifest means we're in bare workflow
    experienceId = '@username/example';
  }
  const expoPushToken = await Notifications.getExpoPushTokenAsync({
    experienceId,
  });
  await fetch('https://example.com/', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      userId,
      expoPushToken,
    }),
  });
}

Returns a native APNS, FCM token or a PushSubscription data that can be used with another push notification service.

A Promise that resolves to an object with the following fields:
  • type (string) -- Either ios, android or web.
  • data (string or object) -- Either the push token as a string (for type == "ios" | "android") or an object conforming to the type below (for type == "web"):
    {
      endpoint: string;
      keys: {
        p256dh: string;
        auth: string;
      }
    }
    

In rare situations a push token may be changed by the push notification service while the app is running. When a token is rolled, the old one becomes invalid and sending notifications to it will fail. A push token listener will let you handle this situation gracefully by registering the new token with your backend right away.

A single and required argument is a function accepting a push token as an argument. It will be called whenever the push token changes.

A Subscription object representing the subscription of the provided listener.

Registering a push token listener using a React hook
import React from 'react';
import * as Notifications from 'expo-notifications';

import { registerDevicePushTokenAsync } from '../api';

export default function App() {
  React.useEffect(() => {
    const subscription = Notifications.addPushTokenListener(registerDevicePushTokenAsync);
    return () => subscription.remove();
  }, []);

  return (
    // Your app content
  );
}

Removes a push token subscription returned by a addPushTokenListener call.

A single and required argument is a subscription returned by addPushTokenListener.

Removes all push token subscriptions that may have been registered with addPushTokenListener.

Listeners registered by this method will be called whenever a notification is received while the app is running.

A single and required argument is a function accepting a notification (Notification) as an argument.

A Subscription object representing the subscription of the provided listener.

Registering a notification listener using a React hook
import React from 'react';
import * as Notifications from 'expo-notifications';

export default function App() {
  React.useEffect(() => {
    const subscription = Notifications.addNotificationReceivedListener(notification => {
      console.log(notification);
    });
    return () => subscription.remove();
  }, []);

  return (
    // Your app content
  );
}

Listeners registered by this method will be called whenever some notifications have been dropped by the server. Applicable only to Firebase Cloud Messaging which we use as notifications service on Android. It corresponds to onDeletedMessages() callback. More information can be found in Firebase docs.

A single and required argument is a function–callback.

A Subscription object representing the subscription of the provided listener.

Listeners registered by this method will be called whenever a user interacts with a notification (eg. taps on it).

A single and required argument is a function accepting notification response (NotificationResponse) as an argument.

A Subscription object representing the subscription of the provided listener.

Registering a notification listener using a React hook
import React from 'react';
import { Linking } from 'react-native';
import * as Notifications from 'expo-notifications';

export default function Container({ navigation }) {
  React.useEffect(() => {
    const subscription = Notifications.addNotificationResponseReceivedListener(response => {
      const url = response.notification.request.content.data.url;
      Linking.openUrl(url);
    });
    return () => subscription.remove();
  }, [navigation]);

  return (
    // Your app content
  );
}

Removes a notification subscription returned by a addNotification*Listener call.

A single and required argument is a subscription returned by addNotification*Listener.

Removes all notification subscriptions that may have been registered with addNotification*Listener.

When a notification is received while the app is running, using this function you can set a callback that will decide whether the notification should be shown to the user or not.
When a notification is received, handleNotification is called with the incoming notification as an argument. The function should respond with a behavior object within 3 seconds, otherwise the notification will be discarded. If the notification is handled successfully, handleSuccess is called with the identifier of the notification, otherwise (or on timeout) handleError will be called.
The default behavior when the handler is not set or does not respond in time is not to show the notification.

The function receives a single argument which should be either null (if you want to clear the handler) or an object of fields:
  • handleNotification ((Notification) => Promise\<NotificationBehavior>) -- (required) a function accepting an incoming notification returning a Promise resolving to a behavior (NotificationBehavior) applicable to the notification
  • handleSuccess ((notificationId: string) => void) -- (optional) a function called whenever an incoming notification is handled successfully
  • handleError ((error: Error) => void) -- (optional) a function called whenever handling of an incoming notification fails

Implementing a notification handler that always shows the notification when it is received
import * as Notifications from 'expo-notifications';

Notifications.setNotificationHandler({
  handleNotification: async () => ({
    shouldShowAlert: true,
    shouldPlaySound: false,
    shouldSetBadge: false,
  }),
});

Calling this function checks current permissions settings related to notifications. It lets you verify whether the app is currently allowed to display alerts, play sounds, etc. There is no user-facing effect of calling this.

It returns a Promise resolving to an object representing permission settings (NotificationPermissionsStatus).

Check if the app is allowed to send any type of notifications (interrupting and non-interrupting–provisional on iOS)
import * as Notifications from 'expo-notifications';

export async function allowsNotificationsAsync() {
  const settings = await Notifications.getPermissionsAsync();
  return (
    settings.granted || settings.ios?.status === Notifications.IosAuthorizationStatus.PROVISIONAL
  );
}

Prompts the user for notification permissions according to request. Request defaults to asking the user to allow displaying alerts, setting badge count and playing sounds.

An optional object of conforming to the following interface:
{
  android?: {};
  ios?: {
    allowAlert?: boolean;
    allowBadge?: boolean;
    allowSound?: boolean;
    allowDisplayInCarPlay?: boolean;
    allowCriticalAlerts?: boolean;
    provideAppNotificationSettings?: boolean;
    allowProvisional?: boolean;
    allowAnnouncements?: boolean;
  }
}
Each option corresponds to a different native platform authorization option (a list of iOS options is available here, on Android all available permissions are granted by default and if a user declines any permission an app can't prompt the user to change).

It returns a Promise resolving to an object representing permission settings (NotificationPermissionsStatus).

Prompts the user to allow the app to show alerts, play sounds, set badge count and let Siri read out messages through AirPods
import * as Notifications from 'expo-notifications';

export function requestPermissionsAsync() {
  return await Notifications.requestPermissionsAsync({
    ios: {
      allowAlert: true,
      allowBadge: true,
      allowSound: true,
      allowAnnouncements: true,
    },
  });
}

Fetches the number currently set as the badge of the app icon on device's home screen. A 0 value means that the badge is not displayed.
Note: Not all Android launchers support application badges. If the launcher does not support icon badges, the method will always resolve to 0.

It returns a Promise resolving to a number representing current badge of the app icon.

Sets the badge of the app's icon to the specified number. Setting to 0 clears the badge.
Note: Not all Android launchers support application badges. If the launcher does not support icon badges, the method will resolve to false.

The function accepts a number as the first argument. A value of 0 will clear the badge.
As a second, optional argument you can pass in an object of options configuring behavior applied in Web environment. The object should be of format:
{
  web?: badgin.Options
}
where the type badgin.Options is an object described in the badgin's documentation.

It returns a Promise resolving to a boolean representing whether setting of the badge succeeded.

Fetches information about all scheduled notifications.

It returns a Promise resolving to an array of objects conforming to the Notification interface.

Schedules a notification for immediate trigger.
Note: This method has been deprecated in favor of using an explicit NotificationHandler and the scheduleNotificationAsync method. More info may be found at https://expo.fyi/presenting-notifications-deprecated.

The only argument to this function is a NotificationContentInput.

It returns a Promise resolving with the notification's identifier once the notification is successfully scheduled for immediate display.

Presenting the notification to the user (deprecated way)
import * as Notifications from 'expo-notifications';

Notifications.presentNotificationAsync({
  title: 'Look at that notification',
  body: "I'm so proud of myself!",
});
Presenting the notification to the user (recommended way)
import * as Notifications from 'expo-notifications';

// First, set the handler that will cause the notification
// to show the alert

Notifications.setNotificationHandler({
  handleNotification: async () => ({
    shouldShowAlert: true,
    shouldPlaySound: false,
    shouldSetBadge: false,
  }),
});

// Second, call the method

Notifications.scheduleNotificationAsync({
  content: {
    title: 'Look at that notification',
    body: "I'm so proud of myself!",
  },
  trigger: null,
});

Schedules a notification to be triggered in the future.
Note: Please note that this does not mean that the notification will be presented when it is triggered. For the notification to be presented you have to set a notification handler with setNotificationHandler that will return an appropriate notification behavior. For more information see the example below.

The one and only argument to this method is a NotificationRequestInput describing the notification to be triggered.

It returns a Promise resolving to a string --- a notification identifier you can later use to cancel the notification or to identify an incoming notification.

Scheduling the notification that will trigger once, in one minute from now
import * as Notifications from 'expo-notifications';

Notifications.scheduleNotificationAsync({
  content: {
    title: "Time's up!",
    body: 'Change sides!',
  },
  trigger: {
    seconds: 60,
  },
});
Scheduling the notification that will trigger repeatedly, every 20 minutes
import * as Notifications from 'expo-notifications';

Notifications.scheduleNotificationAsync({
  content: {
    title: 'Remember to drink water!,
  },
  trigger: {
    seconds: 60 * 20,
    repeats: true
  },
});
Scheduling the notification that will trigger once, at the beginning of next hour
import * as Notifications from 'expo-notifications';

const trigger = new Date(Date.now() + 60 * 60 * 1000);
trigger.setMinutes(0);
trigger.setSeconds(0);

Notifications.scheduleNotificationAsync({
  content: {
    title: 'Happy new hour!',
  },
  trigger,
});

Cancels a single scheduled notification. The scheduled notification of given ID will not trigger.

The notification identifier with which scheduleNotificationAsync resolved when the notification has been scheduled.

A Promise resolving once the scheduled notification is successfully cancelled or if there is no scheduled notification for given identifier.

Scheduling and then canceling the notification
import * as Notifications from 'expo-notifications';

async function scheduleAndCancel() {
  const identifier = await Notifications.scheduleNotificationAsync({
    content: {
      title: 'Hey!',
    },
    trigger: { seconds: 5, repeats: true },
  });
  await Notifications.cancelScheduledNotificationAsync(identifier);
}

Cancels all scheduled notifications.

A Promise resolving once all the scheduled notifications are successfully cancelled or if there are no scheduled notifications.

Fetches information about all notifications present in the notification tray (Notification Center).
Note: This method is not supported on Android below 6.0 (API level 23) – on these devices it will resolve to an empty array.

A Promise resolving with a list of notifications (Notification) currently present in the notification tray (Notification Center).

Removes notification displayed in the notification tray (Notification Center).

The first and only argument to the function is the notification identifier, obtained either in setNotificationHandler or in the listener added with addNotificationReceivedListener.

Resolves once the request to dismiss the notification is successfully dispatched to the notifications manager.

Removes all application's notifications displayed in the notification tray (Notification Center).

Resolves once the request to dismiss the notifications is successfully dispatched to the notifications manager.

Starting in Android 8.0 (API level 26), all notifications must be assigned to a channel. For each channel, you can set the visual and auditory behavior that is applied to all notifications in that channel. Then, users can change these settings and decide which notification channels from your app should be intrusive or visible at all. (source: developer.android.com)
If you do not specify a notification channel, expo-notifications will create a fallback channel for you, named Miscellaneous. We encourage you to always ensure appropriate channels with informative names are set up for the application and to always send notifications to these channels.
Calling these methods is a no-op for platforms that do not support this feature (iOS, Web and Android below version 8.0 (26)).

Fetches information about all known notification channels.

A Promise resolving to an array of channels. On platforms that do not support notification channels, it will always resolve to an empty array.

Fetches information about a single notification channel.

The only argument to this method is the channel's identifier.

A Promise resolving to the channel object (of type NotificationChannel) or to null if there was no channel found for this identifier. On platforms that do not support notification channels, it will always resolve to null.

Assigns the channel configuration to a channel of a specified name (creating it if need be). This method lets you assign given notification channel to a notification channel group.

First argument to the method is the channel identifier.
Second argument is the channel's configuration of type NotificationChannelInput

A Promise resolving to the object (of type NotificationChannel) describing the modified channel or to null if the platform does not support notification channels.

Removes the notification channel.

First and only argument to the method is the channel identifier.

A Promise resolving once the channel is removed (or if there was no channel for given identifier).

Fetches information about all known notification channel groups.

A Promise resolving to an array of channel groups. On platforms that do not support notification channel groups, it will always resolve to an empty array.

Fetches information about a single notification channel group.

The only argument to this method is the channel group's identifier.

A Promise resolving to the channel group object (of type NotificationChannelGroup) or to null if there was no channel group found for this identifier. On platforms that do not support notification channels, it will always resolve to null.

Assigns the channel group configuration to a channel group of a specified name (creating it if need be).

First argument to the method is the channel group identifier.
Second argument is the channel group's configuration of type NotificationChannelGroupInput

A Promise resolving to the object (of type NotificationChannelGroup) describing the modified channel group or to null if the platform does not support notification channels.

Removes the notification channel group and all notification channels that belong to it.

First and only argument to the method is the channel group identifier.

A Promise resolving once the channel group is removed (or if there was no channel group for given identifier).

Notification categories allow you to create interactive push notifications, so that a user can respond directly to the incoming notification either via buttons or a text response. A category defines the set of actions a user can take, and then those actions are applied to a notification by specifying the categoryIdentifier in the NotificationContent.
image of notification categories on iOS and Android
On iOS, notification categories also allow you to customize your notifications further. With each category, not only can you set interactive actions a user can take, but you can also configure things like the placeholder text to display when the user disables notification previews for your app.
Calling one of the following methods is a no-op on Web.

  • identifier: A string to associate as the ID of this category. You will pass this string in as the categoryIdentifier in your NotificationContent to associate a notification with this category.
  • actions: An array of NotificationActions, which describe the actions associated with this category. Each of these actions takes the shape:
    • identifier: A unique string that identifies this action. If a user takes this action (i.e. selects this button in the system's Notification UI), your app will receive this actionIdentifier via the NotificationResponseReceivedListener.
    • buttonTitle: The title of the button triggering this action.
    • textInput: Optional object which, if provided, will result in a button that prompts the user for a text response.
      • submitButtonTitle: (iOS only) A string which will be used as the title for the button used for submitting the text response.
      • placeholder: A string that serves as a placeholder until the user begins typing. Defaults to no placeholder string.
    • options: Optional object of additional configuration options.
      • opensAppToForeground: Boolean indicating whether triggering this action foregrounds the app.
      • isAuthenticationRequired: (iOS only) Boolean indicating whether triggering the action will require authentication from the user.
      • isDestructive: (iOS only) Boolean indicating whether the button title will be highlighted a different color (usually red). This usually signifies a destructive action such as deleting data.
  • options: An optional object of additional configuration options for your category (these are all iOS only):
    • previewPlaceholder: Customizable placeholder for the notification preview text. This is shown if the user has disabled notification previews for the app. Defaults to the localized iOS system default placeholder (Notification).
    • intentIdentifiers: Array of Intent Class Identifiers. When a notification is delivered, the presence of an intent identifier lets the system know that the notification is potentially related to the handling of a request made through Siri. Defaults to an empty array.
    • categorySummaryFormat: A format string for the summary description used when the system groups the category’s notifications.
    • customDismissAction: A boolean indicating whether to send actions for handling when the notification is dismissed (the user must explicitly dismiss the notification interface- ignoring a notification or flicking away a notification banner does not trigger this action). Defaults to false.
    • allowInCarPlay: A boolean indicating whether to allow CarPlay to display notifications of this type. Apps must be approved for CarPlay to make use of this feature. Defaults to false.
    • showTitle: A boolean indicating whether to show the notification's title, even if the user has disabled notification previews for the app. Defaults to false.
    • showSubtitle: A boolean indicating whether to show the notification's subtitle, even if the user has disabled notification previews for the app. Defaults to false.
    • allowAnnouncment: A boolean indicating whether to allow notifications to be automatically read by Siri when the user is using AirPods. Defaults to false.

A Promise resolving to the category you just created.

Fetches information about all known notification categories.

A Promise resolving to an array of NotificationCategorys. On platforms that do not support notification channels, it will always resolve to an empty array.

Deletes the category associated with the provided identifier.

Identifier initially provided to setNotificationCategoryAsync when creating the category.

A Promise resolving to true if the category was successfully deleted, or false if it was not. An example of when this method would return false is if you try to delete a category that doesn't exist.

In simple terms, an object of type: Platform.OS and data: any. The data type depends on the environment -- on a native device it will be a string, which you can then use to send notifications via Firebase Cloud Messaging (Android) or APNS (iOS); on web it will be a registration object (VAPID).
export interface NativeDevicePushToken {
  type: 'ios' | 'android';
  data: string;
}

export interface WebDevicePushToken {
  type: 'web';
  data: {
    endpoint: string;
    keys: {
      p256dh: string;
      auth: string;
    };
  };
}

export type DevicePushToken = NativeDevicePushToken | WebDevicePushToken;

A function accepting a device push token (DevicePushToken) as an argument.
Note: You should not call getDevicePushTokenAsync inside this function, as it triggers the listener and may lead to an infinite loop.

Borrowing from DevicePushToken a little bit, it's an object of type: 'expo' and data: string. You can use the data value to send notifications via Expo Notifications service.
export interface ExpoPushToken {
  type: 'expo';
  data: string;
}

A common-in-React-Native type to abstract an active subscription. Call .remove() to remove the subscription. You can then discard the object.
export type Subscription = {
  remove: () => void;
};

An object representing a single notification that has been triggered by some request (NotificationRequest) at some point in time.
export interface Notification {
  date: number;
  request: NotificationRequest;
}

An object representing a request to present a notification. It has content — how it's being represented — and a trigger — what triggers the notification. Many notifications (Notification) may be triggered with the same request (eg. a repeating notification).
export interface NotificationRequest {
  identifier: string;
  content: NotificationContent;
  trigger: NotificationTrigger;
}

An object representing notification's content.
export type NotificationContent = {
  // Notification title - the bold text displayed above the rest of the content
  title: string | null;
  // On iOS - subtitle - the bold text displayed between title and the rest of the content
  // On Android - subText - the display depends on the platform
  subtitle: string | null;
  // Notification body - the main content of the notification
  body: string | null;
  // Data associated with the notification, not displayed
  data: { [key: string]: unknown };
  // Application badge number associated with the notification
  badge: number | null;
  sound: 'default' | 'defaultCritical' | 'custom' | null;
} & (
  | {
      // iOS-specific additions
      // See https://developer.apple.com/documentation/usernotifications/unnotificationcontent?language=objc
      // for more information on specific fields.
      launchImageName: string | null;
      attachments: {
        identifier: string | null;
        url: string | null;
        type: string | null;
      }[];
      summaryArgument?: string | null;
      summaryArgumentCount?: number;
      categoryIdentifier: string | null;
      threadIdentifier: string | null;
      targetContentIdentifier?: string;
    }
  | {
      // Android-specific additions
      // See https://developer.android.com/reference/android/app/Notification.html#fields
      // for more information on specific fields.
      priority?: AndroidNotificationPriority;
      vibrationPattern?: number[];
      // Format: '#AARRGGBB'
      color?: string;
    }
  );

An object representing notification content that you pass in to presentNotificationAsync or as a part of NotificationRequestInput.
export interface NotificationContentInput {
  // Fields corresponding to NotificationContent
  title?: string;
  subtitle?: string;
  body?: string;
  data?: { [key: string]: unknown };
  badge?: number;
  sound?: boolean | string;

  // Android-specific fields
  // See https://developer.android.com/reference/android/app/Notification.html#fields
  // for more information on specific fields.
  vibrate?: boolean | number[];
  priority?: AndroidNotificationPriority;
  // Format: '#AARRGGBB', '#RRGGBB' or one of the named colors,
  // see https://developer.android.com/reference/kotlin/android/graphics/Color?hl=en
  color?: string;
  // If set to false, the notification will not be automatically dismissed when clicked.
  // The setting used when the value is not provided or is invalid is true (the notification
  // will be dismissed automatically). Corresponds directly to Android's `setAutoCancel`
  // behavior. In Firebase terms this property of a notification is called `sticky`.
  // See:
  // - https://developer.android.com/reference/android/app/Notification.Builder#setAutoCancel(boolean),
  // - https://firebase.google.com/docs/reference/fcm/rest/v1/projects.messages#AndroidNotification.FIELDS.sticky
  autoDismiss?: boolean;
  // If set to true, the notification cannot be dismissed by swipe. This setting defaults
  // to false if not provided or is invalid. Corresponds directly do Android's `isOngoing` behavior.
  // See: https://developer.android.com/reference/android/app/Notification.Builder#setOngoing(boolean)
  sticky?: boolean;

  // iOS-specific fields
  // See https://developer.apple.com/documentation/usernotifications/unmutablenotificationcontent?language=objc
  // for more information on specific fields.
  launchImageName?: string;
  attachments?: {
    url: string;
    identifier?: string;

    typeHint?: string;
    hideThumbnail?: boolean;
    thumbnailClipArea?: { x: number; y: number; width: number; height: number };
    thumbnailTime?: number;
  }[];
}

An object representing a notification request you can pass into scheduleNotificationAsync.
export interface NotificationRequestInput {
  identifier?: string;
  content: NotificationContentInput;
  trigger: NotificationTriggerInput;
}

An enum corresponding to values appropriate for Android's Notification#priority field.
export enum AndroidNotificationPriority {
  MIN = 'min',
  LOW = 'low',
  DEFAULT = 'default',
  HIGH = 'high',
  MAX = 'max',
}

A union type containing different triggers which may cause the notification to be delivered to the application.
export type NotificationTrigger =
  | PushNotificationTrigger
  | CalendarNotificationTrigger
  | LocationNotificationTrigger
  | TimeIntervalNotificationTrigger
  | DailyNotificationTrigger
  | UnknownNotificationTrigger;

An object representing a notification delivered by a push notification system.
On Android under remoteMessage field a JS version of the Firebase RemoteMessage may be accessed.
export interface PushNotificationTrigger {
  type: 'push';
  remoteMessage?: FirebaseRemoteMessage;
}

A Firebase RemoteMessage that caused the notification to be delivered to the app.
export interface FirebaseRemoteMessage {
  collapseKey: string | null;
  data: { [key: string]: string };
  from: string | null;
  messageId: string | null;
  messageType: string | null;
  originalPriority: number;
  priority: number;
  sentTime: number;
  to: string | null;
  ttl: number;
  notification: null | {
    body: string | null;
    bodyLocalizationArgs: string[] | null;
    bodyLocalizationKey: string | null;
    channelId: string | null;
    clickAction: string | null;
    color: string | null;
    usesDefaultLightSettings: boolean;
    usesDefaultSound: boolean;
    usesDefaultVibrateSettings: boolean;
    eventTime: number | null;
    icon: string | null;
    imageUrl: string | null;
    lightSettings: number[] | null;
    link: string | null;
    localOnly: boolean;
    notificationCount: number | null;
    notificationPriority: number | null;
    sound: string | null;
    sticky: boolean;
    tag: string | null;
    ticker: string | null;
    title: string | null;
    titleLocalizationArgs: string[] | null;
    titleLocalizationKey: string | null;
    vibrateTimings: number[] | null;
    visibility: number | null;
  };
}

A trigger related to an elapsed time interval. May be repeating (see repeats field).
export interface TimeIntervalNotificationTrigger {
  type: 'timeInterval';
  repeats: boolean;
  seconds: number;
}

A trigger related to a daily notification. This is an Android-only type, the same functionality will be achieved on iOS with a CalendarNotificationTrigger.
export interface DailyNotificationTrigger {
  type: 'daily';
  hour: number;
  minute: number;
}

A trigger related to a UNCalendarNotificationTrigger, available only on iOS.
export interface CalendarNotificationTrigger {
  type: 'calendar';
  repeats: boolean;
  dateComponents: {
    era?: number;
    year?: number;
    month?: number;
    day?: number;
    hour?: number;
    minute?: number;
    second?: number;
    weekday?: number;
    weekdayOrdinal?: number;
    quarter?: number;
    weekOfMonth?: number;
    weekOfYear?: number;
    yearForWeekOfYear?: number;
    nanosecond?: number;
    isLeapMonth: boolean;
    timeZone?: string;
    calendar?: string;
  };
}

A trigger related to a UNLocationNotificationTrigger, available only on iOS.
export interface LocationNotificationTrigger {
  type: 'location';
  repeats: boolean;
  region: CircularRegion | BeaconRegion;
}

interface Region {
  type: string;
  identifier: string;
  notifyOnEntry: boolean;
  notifyOnExit: boolean;
}

export interface CircularRegion extends Region {
  type: 'circular';
  radius: number;
  center: {
    latitude: number;
    longitude: number;
  };
}

export interface BeaconRegion extends Region {
  type: 'beacon';
  notifyEntryStateOnDisplay: boolean;
  major: number | null;
  minor: number | null;
  uuid?: string;
  beaconIdentityConstraint?: {
    uuid: string;
    major: number | null;
    minor: number | null;
  };
}

Represents a notification trigger that is unknown to expo-notifications and that it didn't know how to serialize for JS.
export interface UnknownNotificationTrigger {
  type: 'unknown';
}

A type representing possible triggers with which you can schedule notifications. A null trigger means that the notification should be scheduled for delivery immediately.
export type NotificationTriggerInput =
  | null
  | ChannelAwareTriggerInput
  | DateTriggerInput
  | TimeIntervalTriggerInput
  | DailyTriggerInput
  | CalendarTriggerInput;

A trigger that will cause the notification to be delivered immediately.
export type ChannelAwareTriggerInput = {
  channelId: string;
};

A trigger that will cause the notification to be delivered once at the specified Date. If you pass in a number it will be interpreted as a UNIX timestamp.
export type DateTriggerInput = Date | number | { channelId?: string; date: Date | number };

A trigger that will cause the notification to be delivered once or many times (depends on the repeats field) after seconds time elapse.
export interface TimeIntervalTriggerInput {
  channelId?: string;
  repeats?: boolean;
  seconds: number;
}

A trigger that will cause the notification to be delivered once per day.
export interface DailyTriggerInput {
  channelId?: string;
  hour: number;
  minute: number;
  repeats: true;
}

A trigger that will cause the notification to be delivered once or many times when the date components match the specified values. Corresponds to native UNCalendarNotificationTrigger.
Note: This type of trigger is only available on iOS.
export interface CalendarTriggerInput {
  channelId?: string;
  repeats?: boolean;
  timezone?: string;

  year?: number;
  month?: number;
  weekday?: number;
  weekOfMonth?: number;
  weekOfYear?: number;
  weekdayOrdinal?: number;
  day?: number;

  hour?: number;
  minute?: number;
  second?: number;
}

An object representing user's interaction with the notification.
Note: If the user taps on a notification actionIdentifier will be equal to Notifications.DEFAULT_ACTION_IDENTIFIER.
export interface NotificationResponse {
  notification: Notification;
  actionIdentifier: string;
  userText?: string;
}

An object representing behavior that should be applied to the incoming notification.
export interface NotificationBehavior {
  shouldShowAlert: boolean;
  shouldPlaySound: boolean;
  shouldSetBadge: boolean;
  priority?: AndroidNotificationPriority;
}

An object representing a notification channel (feature available only on Android).
export enum AndroidNotificationVisibility {
  UNKNOWN,
  PUBLIC,
  PRIVATE,
  SECRET,
}

export enum AndroidAudioContentType {
  UNKNOWN,
  SPEECH,
  MUSIC,
  MOVIE,
  SONIFICATION,
}

export enum AndroidImportance {
  UNKNOWN,
  UNSPECIFIED,
  NONE,
  MIN,
  LOW,
  DEFAULT,
  HIGH,
  MAX,
}

export enum AndroidAudioUsage {
  UNKNOWN,
  MEDIA,
  VOICE_COMMUNICATION,
  VOICE_COMMUNICATION_SIGNALLING,
  ALARM,
  NOTIFICATION,
  NOTIFICATION_RINGTONE,
  NOTIFICATION_COMMUNICATION_REQUEST,
  NOTIFICATION_COMMUNICATION_INSTANT,
  NOTIFICATION_COMMUNICATION_DELAYED,
  NOTIFICATION_EVENT,
  ASSISTANCE_ACCESSIBILITY,
  ASSISTANCE_NAVIGATION_GUIDANCE,
  ASSISTANCE_SONIFICATION,
  GAME,
}

export interface AudioAttributes {
  usage: AndroidAudioUsage;
  contentType: AndroidAudioContentType;
  flags: {
    enforceAudibility: boolean;
    requestHardwareAudioVideoSynchronization: boolean;
  };
}

export interface NotificationChannel {
  id: string;
  name: string | null;
  importance: AndroidImportance;
  bypassDnd: boolean;
  description: string | null;
  groupId?: string | null;
  lightColor: string;
  lockscreenVisibility: AndroidNotificationVisibility;
  showBadge: boolean;
  sound: 'default' | 'custom' | null;
  audioAttributes: AudioAttributes;
  vibrationPattern: number[] | null;
  enableLights: boolean;
  enableVibrate: boolean;
}

An object representing a notification channel to be set.
export interface NotificationChannelInput {
  name: string | null;
  importance: AndroidImportance;
  // Optional attributes
  bypassDnd?: boolean;
  description?: string | null;
  groupId?: string | null;
  lightColor?: string;
  lockscreenVisibility?: AndroidNotificationVisibility;
  showBadge?: boolean;
  sound?: string | null;
  audioAttributes?: Partial<AudioAttributes>;
  vibrationPattern?: number[] | null;
  enableLights?: boolean;
  enableVibrate?: boolean;
}

An object representing a notification channel group (feature available only on Android).
export interface NotificationChannelGroup {
  id: string;
  name: string | null;
  description?: string | null;
  isBlocked?: boolean;
  channels: NotificationChannel[];
}

An object representing a notification channel group to be set.
export interface NotificationChannelGroupInput {
  name: string | null;
  description?: string | null;
}

export interface NotificationCategory {
  identifier: string;
  actions: NotificationAction[];
  options: {
    // These options are ALL iOS-only
    previewPlaceholder?: string;
    intentIdentifiers?: string[];
    categorySummaryFormat?: string;
    customDismissAction?: boolean;
    allowInCarPlay?: boolean;
    showTitle?: boolean;
    showSubtitle?: boolean;
    allowAnnouncement?: boolean;
  };
}

export interface NotificationAction {
  identifier: string;
  buttonTitle: string;
  textInput?: {
    submitButtonTitle: string;
    placeholder: string;
  };
  options: {
    isDestructive?: boolean;
    isAuthenticationRequired?: boolean;
    opensAppToForeground?: boolean;
  };
}