### Install Expo Notifications

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Use this command to install the expo-notifications package for your project. This command works across different package managers.

```sh
npx expo install expo-notifications
```

```sh
yarn expo install expo-notifications
```

```sh
pnpm expo install expo-notifications
```

```sh
bun expo install expo-notifications
```

--------------------------------

### Manually Configure Notification Channel and Schedule Notification (Android)

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Manually configure a notification channel with a custom sound file (e.g., email_sound.wav) placed in android/app/src/main/res/raw/. This example shows setting the channel sound for Android 8.0+ and the content sound for older Android versions.

```typescript
// Prepare the notification channel
await Notifications.setNotificationChannelAsync('new_emails', {
  name: 'E-mail notifications',
  importance: Notifications.AndroidImportance.HIGH,
  sound: 'email_sound.wav', // <- for Android 8.0+, see channelId property below
});

// Eg. schedule the notification
await Notifications.scheduleNotificationAsync({
  content: {
    title: "You've got mail! 📬",
    body: 'Open the notification to read them all',
    sound: 'email_sound.wav', // <- for Android below 8.0
  },
  trigger: {
    type: Notifications.SchedulableTriggerInputTypes.TIME_INTERVAL,
    seconds: 2,
    channelId: 'new_emails', // <- for Android 8.0+, see definition above
  },
});
```

--------------------------------

### Schedule and Cancel a Notification

Source: https://docs.expo.dev/versions/latest/sdk/notifications

This example demonstrates scheduling a notification with a title and a repeating trigger, then immediately canceling it using its identifier. Ensure you have requested notification permissions before scheduling.

```typescript
import * as Notifications from 'expo-notifications';

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

--------------------------------

### Configure Expo Notifications Plugin

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Example of configuring the 'expo-notifications' plugin in your app.json or app.config.js file. This allows setting properties like icon, color, default channel, and custom sounds for push notifications.

```json
{
  "expo": {
    "plugins": [
      [
        "expo-notifications",
        {
          "icon": "./local/assets/notification_icon.png",
          "color": "#ffffff",
          "defaultChannel": "default",
          "sounds": [
            "./local/assets/notification_sound.wav",
            "./local/assets/notification_sound_other.wav"
          ],
          "enableBackgroundRemoteNotifications": false
        }
      ]
    ]
  }
}
```

--------------------------------

### Expo Notifications App Example

Source: https://docs.expo.dev/versions/latest/sdk/notifications

This snippet demonstrates a full React Native app component for handling push notifications. It includes token registration, channel management for Android, and listeners for received notifications and responses. Ensure you have configured your project with a projectId for EAS.

```tsx
import { useState, useEffect } from 'react';
import { Text, View, Button, Platform } from 'react-native';
import * as Notifications from 'expo-notifications';
import Constants from 'expo-constants';

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

export default function App() {
  const [expoPushToken, setExpoPushToken] = useState('');
  const [channels, setChannels] = useState<Notifications.NotificationChannel[]>([]);
  const [notification, setNotification] = useState<Notifications.Notification | undefined>(
    undefined
  );

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

    if (Platform.OS === 'android') {
      Notifications.getNotificationChannelsAsync().then(value => setChannels(value ?? []));
    }
    const notificationListener = Notifications.addNotificationReceivedListener(notification => {
      setNotification(notification);
    });

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

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

  return (
    <View
      style={{
        flex: 1,
        alignItems: 'center',
        justifyContent: 'space-around',
      }}>
      <Text>Your expo push token: {expoPushToken}</Text>
      <Text>{`Channels: ${JSON.stringify(
        channels.map(c => c.id),
        null,
        2
      )}`}</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', test: { test1: 'more data' } },
    },
    trigger: {
      type: Notifications.SchedulableTriggerInputTypes.TIME_INTERVAL,
      seconds: 2,
    },
  });
}

async function registerForPushNotificationsAsync() {
  let token;

  if (Platform.OS === 'android') {
    await Notifications.setNotificationChannelAsync('myNotificationChannel', {
      name: 'A channel is needed for the permissions prompt to appear',
      importance: Notifications.AndroidImportance.MAX,
      vibrationPattern: [0, 250, 250, 250],
      lightColor: '#FF231F7C',
    });
  }

  const { status: existingStatus } = await Notifications.getPermissionsAsync();
  let finalStatus = existingStatus;
  if (existingStatus !== 'granted') {
    const { status } = await Notifications.requestPermissionsAsync();
    finalStatus = status;
  }
  if (finalStatus !== 'granted') {
    alert('Failed to get push token for push notification!');
    return;
  }
  // Learn more about projectId:
  // https://docs.expo.dev/push-notifications/push-notifications-setup/#configure-projectid
  // EAS projectId is used here.
  try {
    const projectId = 
      Constants?.expoConfig?.extra?.eas?.projectId ?? Constants?.easConfig?.projectId;
    if (!projectId) {
      throw new Error('Project ID not found');
    }
    token = (
      await Notifications.getExpoPushTokenAsync({
        projectId,
      })
    ).data;
    console.log(token);
  } catch (e) {
    token = `${e}`;
  }

  return token;
}

```

--------------------------------

### Get Presented Notifications

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Fetches information about all notifications currently displayed in the notification tray. Note: Not supported on Android below API level 23.

```typescript
import * as Notifications from 'expo-notifications';

async function logPresentedNotifications() {
  const notifications = await Notifications.getPresentedNotificationsAsync();
  console.log('Presented notifications:', notifications);
}
```

--------------------------------

### Add Notification Response Received Listener

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Registers a listener that is called when a user interacts with a notification, such as tapping on it. This example opens a URL from the notification data. Ensure to remove the subscription.

```jsx
import React from 'react';
import { Linking } from 'react-native';
import * as Notifications from 'expo-notifications';

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

  return (
    // Your app content
  );
}
```

--------------------------------

### Submit Documentation Feedback

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Use this cURL command to submit feedback about the documentation. Ensure you replace the placeholder with specific, actionable feedback.

```sh
curl -X POST https://api.expo.dev/v2/feedback/docs-send -H "Content-Type: application/json" -d '{"url":"/versions/latest/sdk/notifications/","feedback":"🤖 Agent feedback for docs: <specific, actionable description> (<model>, <harness>)"}'
```

--------------------------------

### Notifications.getLastNotificationResponseAsync

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Gets the most recently received notification response asynchronously. Supported on Android and iOS.

```APIDOC
## Notifications.getLastNotificationResponseAsync()

### Description
Gets the notification response received most recently (a notification response designates an interaction with a notification, such as tapping on it).

### Method
Not applicable (SDK method)

### Endpoint
Not applicable (SDK method)

### Parameters
None

### Request Example
```javascript
Notifications.getLastNotificationResponseAsync();
```

### Response
#### Success Response
* **Promise<notificationresponse>** - A Promise which resolves to a [`NotificationResponse`](#notificationresponse) object, or `null` if no notification response has been received yet.

### Response Example
```json
{
  "notification": {
    "request": {
      "content": {
        "title": "Hello",
        "body": "World"
      }
    }
  },
  "actionIdentifier": "reply",
  "inputs": []
}
```
```

--------------------------------

### NotificationChannelManager

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Manages notification channels on Android and iOS. Provides methods to get, set, and delete notification channels.

```APIDOC
## NotificationChannelManager

### Description
Manages notification channels on Android and iOS. Provides methods to get, set, and delete notification channels.

### Methods

- **`deleteNotificationChannelAsync(channelId: string)`**
  - Description: Deletes a notification channel.
  - Parameters:
    - `channelId` (string) - The ID of the channel to delete.
  - Returns: A Promise that resolves when the channel is deleted.

- **`getNotificationChannelAsync(channelId: string)`**
  - Description: Retrieves a specific notification channel.
  - Parameters:
    - `channelId` (string) - The ID of the channel to retrieve.
  - Returns: A Promise that resolves with the `NotificationChannel` object or null if not found.

- **`getNotificationChannelsAsync()`**
  - Description: Retrieves all notification channels.
  - Returns: A Promise that resolves with an array of `NotificationChannel` objects or null.

- **`setNotificationChannelAsync(channelId: string, channelConfiguration: NotificationChannelInput)`**
  - Description: Creates or updates a notification channel.
  - Parameters:
    - `channelId` (string) - The ID of the channel to set.
    - `channelConfiguration` (NotificationChannelInput) - The configuration for the notification channel.
  - Returns: A Promise that resolves with the created or updated `NotificationChannel` object or null.
```

--------------------------------

### Listen for Push Token Changes

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Register a listener to handle changes in the device's push token. This is useful for updating the token with your backend when it changes.

```jsx
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
  );
}
```

--------------------------------

### NotificationChannelGroupManager

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Manages notification channel groups on Android. Provides methods to get, set, and delete channel groups.

```APIDOC
## NotificationChannelGroupManager

### Description
Manages notification channel groups on Android. Provides methods to get, set, and delete channel groups.

### Methods

- **`deleteNotificationChannelGroupAsync(groupId: string)`**
  - Description: Deletes a notification channel group.
  - Parameters:
    - `groupId` (string) - The ID of the group to delete.
  - Returns: A Promise that resolves when the group is deleted.

- **`getNotificationChannelGroupAsync(groupId: string)`**
  - Description: Retrieves a specific notification channel group.
  - Parameters:
    - `groupId` (string) - The ID of the group to retrieve.
  - Returns: A Promise that resolves with the `NotificationChannelGroup` object or null if not found.

- **`getNotificationChannelGroupsAsync()`**
  - Description: Retrieves all notification channel groups.
  - Returns: A Promise that resolves with an array of `NotificationChannelGroup` objects.

- **`setNotificationChannelGroupAsync(groupId: string, group: NotificationChannelGroupInput)`**
  - Description: Creates or updates a notification channel group.
  - Parameters:
    - `groupId` (string) - The ID of the group to set.
    - `group` (NotificationChannelGroupInput) - The configuration for the notification channel group.
  - Returns: A Promise that resolves with the created or updated `NotificationChannelGroup` object or null.
```

--------------------------------

### Notifications.getLastNotificationResponse

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Gets the most recently received notification response. This method is deprecated and `getLastNotificationResponseAsync` should be used instead. Supported on Android and iOS.

```APIDOC
## Notifications.getLastNotificationResponse()

### Description
Gets the notification response that was received most recently (a notification response designates an interaction with a notification, such as tapping on it).

### Method
Not applicable (SDK method)

### Endpoint
Not applicable (SDK method)

### Parameters
None

### Request Example
```javascript
Notifications.getLastNotificationResponse();
```

### Response
#### Success Response
* **NotificationResponse | null** - `null` if no notification response has been received yet, or a [`NotificationResponse`](#notificationresponse) object if a notification response was received.

### Response Example
```json
{
  "notification": {
    "request": {
      "content": {
        "title": "Hello",
        "body": "World"
      }
    }
  },
  "actionIdentifier": "reply",
  "inputs": []
}
```
```

--------------------------------

### IosAlertStyle

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Enum constants for iOS alert styles.

```APIDOC
## IosAlertStyle

### Description
Enum constants for iOS alert styles.

### Constants
- **NONE** (`0`)
- **BANNER** (`1`)
- **ALERT** (`2`)
```

--------------------------------

### ExpoPushTokenOptions

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Options for configuring Expo Push Tokens, including application ID, base URL, development mode, device ID, device push token, project ID, and request overrides.

```APIDOC
## ExpoPushTokenOptions

Supported platforms: Android, iOS.

### Description
Options for configuring Expo Push Tokens.

### Properties
- **applicationId** (string) - Optional - The ID of the application to which the token should be attributed. Defaults to [`Application.applicationId`](/versions/latest/sdk/application#applicationapplicationid) exposed by `expo-application`.
- **baseUrl** (string) - Optional - Endpoint URL override.
- **development** (boolean) - Optional - Supported platforms: iOS. On iOS, 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()`](/versions/latest/sdk/application#applicationgetiospushnotificationserviceenvironmentasync) 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.
- **deviceId** (string) - Optional - 
- **devicePushToken** (DevicePushToken) - Optional - The device push token with which to register at the backend. Defaults to a token fetched with [`getDevicePushTokenAsync()`](#getdevicepushtokenasync).
- **projectId** (string) - Optional - The ID of the project to which the token should be attributed. Defaults to [`Constants.expoConfig.extra.eas.projectId`](/versions/latest/sdk/constants#easconfig) exposed by `expo-constants`. When using EAS Build, this value is automatically set. However, it is **recommended** to set it manually. Once you have EAS Build configured, you can find the value in **app.json** under `extra.eas.projectId`. You can copy and paste it into your code. If you are not using EAS Build, it will fallback to [`Constants.expoConfig?.extra?.eas?.projectId`](/versions/latest/sdk/constants#manifest).
- **type** (string) - Optional - Request body override.
- **url** (string) - Optional - Request URL override.
```

--------------------------------

### Get Next Trigger Date

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Calculates the next trigger date for a given notification trigger input. Returns null if the notification will not be triggered.

```typescript
import * as Notifications from 'expo-notifications';

async function logNextTriggerDate() {
  try {
    const nextTriggerDate = await Notifications.getNextTriggerDateAsync({
      hour: 9,
      minute: 0,
    });
    console.log(nextTriggerDate === null ? 'No next trigger date' : new Date(nextTriggerDate));
  } catch (e) {
    console.warn(`Couldn't have calculated next trigger date: ${e}`);
  }
}
```

--------------------------------

### IosAllowsPreviews

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Enum constants for iOS notification preview settings.

```APIDOC
## IosAllowsPreviews

### Description
Enum constants for iOS notification preview settings.

### Constants
- **NEVER** (`0`)
- **ALWAYS** (`1`)
- **WHEN_AUTHENTICATED** (`2`)
```

--------------------------------

### iOS Preview Settings

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Controls whether previews are shown for iOS notifications.

```javascript
IosAllowsPreviews.NEVER = 0
```

```javascript
IosAllowsPreviews.ALWAYS = 1
```

```javascript
IosAllowsPreviews.WHEN_AUTHENTICATED = 2
```

--------------------------------

### PushTokenListener(token)

Source: https://docs.expo.dev/versions/latest/sdk/notifications

A function that accepts a device push token and is called when a token is received. Avoid calling getDevicePushTokenAsync within this listener to prevent infinite loops.

```APIDOC
## PushTokenListener(token)

Supported platforms: Android, iOS.

A function accepting a device push token ([`DevicePushToken`](#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.

### Parameters

- **token** ([DevicePushToken](#devicepushtoken))

Returns:

`void`
```

--------------------------------

### Use Last Notification Response Hook

Source: https://docs.expo.dev/versions/latest/sdk/notifications

A React hook to access the most recent notification response. It can return undefined, null, or a NotificationResponse object. The example demonstrates opening a URL based on the response data.

```jsx
import * as Notifications from 'expo-notifications';
import { Linking } from 'react-native';

export default function App() {
  const lastNotificationResponse = Notifications.useLastNotificationResponse();
  React.useEffect(() => {
    if (
      lastNotificationResponse &&
      lastNotificationResponse.notification.request.content.data.url &&
      lastNotificationResponse.actionIdentifier === Notifications.DEFAULT_ACTION_IDENTIFIER
    ) {
      Linking.openURL(lastNotificationResponse.notification.request.content.data.url);
    }
  }, [lastNotificationResponse]);
  return (
    // Your app content
  );
}
```

--------------------------------

### Schedule Notification with Custom Sound (iOS)

Source: https://docs.expo.dev/versions/latest/sdk/notifications

On iOS, after placing the sound file in your Xcode project, specify the sound file in the 'sound' property of the notification content.

```typescript
await Notifications.scheduleNotificationAsync({
  content: {
    title: "You've got mail! 📬",
    body: 'Open the notification to read them all',
    sound: 'notification.wav',
  },
  trigger: {
    // ...
  },
});
```

--------------------------------

### Get Expo Push Token

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Asynchronously retrieve an Expo push token for the device. This token is used to send notifications via Expo's push notification service. Ensure you handle potential request rejections with a try/catch block.

```typescript
import * as Notifications from 'expo-notifications';

export async function registerForPushNotificationsAsync(userId: string) {
  const expoPushToken = await Notifications.getExpoPushTokenAsync({
   projectId: 'your-project-id',
  });

  await fetch('https://example.com/', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      userId,
      expoPushToken,
    }),
  });
}
```

--------------------------------

### Schedule Local Notification

Source: https://docs.expo.dev/versions/latest/sdk/notifications

This snippet shows how to present a local in-app notification. It requires setting a notification handler and then calling `scheduleNotificationAsync` with content and a null trigger for immediate display.

```ts
import * as Notifications from 'expo-notifications';

// First, set the handler that will cause the notification
// to show the alert
Notifications.setNotificationHandler({
  handleNotification: async () => ({
    shouldPlaySound: false,
    shouldSetBadge: false,
    shouldShowBanner: true,
    shouldShowList: true,
  }),
});

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

```

--------------------------------

### requestPermissionsAsync

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Prompts the user to grant notification permissions. It allows specifying which types of permissions (alerts, badge, sound) to request. The function returns the updated permission status after the user's interaction.

```APIDOC
## requestPermissionsAsync(permissions)

### Description
Supported platforms: Android, iOS. Prompts the user for notification permissions according to the request. Defaults to asking the user to allow displaying alerts, setting badge count, and playing sounds.

### Parameters
#### Request Body
- **permissions** (`NotificationPermissionsRequest`) - Optional - An object representing configuration for the request scope.

### Returns
`Promise<notificationpermissionsstatus>` - A Promise resolving to an object representing permission settings.
```

--------------------------------

### IosAuthorizationStatus

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Enum constants for iOS authorization status.

```APIDOC
## IosAuthorizationStatus

### Description
Enum constants for iOS authorization status.

### Constants
- **NOT_DETERMINED** (`0`)
- **DENIED** (`1`)
- **AUTHORIZED** (`2`)
- **PROVISIONAL** (`3`)
- **EPHEMERAL** (`4`)
```

--------------------------------

### NotificationHandler

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Handles incoming notifications and their behaviors.

```APIDOC
## NotificationHandler

### Description
Handles incoming notifications and their behaviors.

### Methods

- **`handleError(notificationId: string, error: NotificationHandlingError)`**
  - Description: A function called whenever calling `handleNotification()` for an incoming notification fails.
  - Parameters:
    - `notificationId` (string) - The ID of the notification that failed.
    - `error` (NotificationHandlingError) - The error object.

- **`handleNotification(notification: Notification)`**
  - Description: A function accepting an incoming notification.
  - Parameters:
    - `notification` (Notification) - The incoming notification object.
  - Returns: A Promise resolving to a `NotificationBehavior` applicable to the notification.

- **`handleSuccess(notificationId: string)`**
  - Description: A function called whenever an incoming notification is handled successfully.
  - Parameters:
    - `notificationId` (string) - The ID of the notification that was handled successfully.
```

--------------------------------

### PermissionStatus

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Enum constants for permission status on Android and iOS.

```APIDOC
## PermissionStatus

### Description
Enum constants for permission status on Android and iOS.

### Constants
- **DENIED** (`"denied"`): User has denied the permission.
- **GRANTED** (`"granted"`): User has granted the permission.
- **UNDETERMINED** (`"undetermined"`): User hasn't granted or denied the permission yet.
```

--------------------------------

### Import Expo Notifications

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Import the Notifications module from the expo-notifications library.

```javascript
import * as Notifications from 'expo-notifications';
```

--------------------------------

### ImplicitlySupportedDevicePushToken

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Represents a device push token where the type is implicitly determined. The `data` property holds the token string, and `type` specifies the platform.

```APIDOC
## ImplicitlySupportedDevicePushToken

### Parameters
#### Path Parameters
- **data** (any) - Required - Description: The push token as a string for a native platform.
- **type** (Exclude<Platform.OS, ExplicitlySupportedDevicePushToken[type]">) - Required - Description: Either `android` or `ios`.
```

--------------------------------

### setNotificationHandler

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Sets a callback to decide whether to show a notification when the app is running. The handler must respond within 3 seconds with a behavior object.

```APIDOC
## `setNotificationHandler(handler)`

### Description
Supported platforms: Android, iOS. When a notification is received while the app is running, this function sets a callback that decides whether the notification should be shown to the user.

### Parameters
#### Path Parameters
- **handler** (NotificationHandler | null) - Required - A single parameter which should be either `null` (to clear the handler) or a [`NotificationHandler`](#notificationhandler) object.

### Request Example
```jsx
import * as Notifications from 'expo-notifications';

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

### Response
Returns: `void`
```

--------------------------------

### getBadgeCountAsync

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Fetches the current badge count displayed on the app icon. Returns 0 if the badge is not displayed or if the device's launcher does not support badges.

```APIDOC
## getBadgeCountAsync()

### Description
Supported platforms: Android, iOS. Fetches the number currently set as the badge of the app icon on the device's home screen. A `0` value means that the badge is not displayed. Note: Not all Android launchers support application badges; if unsupported, the method will always resolve to `0`.

### Returns
`Promise<number>` - A Promise resolving to a number representing the current badge count.
```

--------------------------------

### Configure Custom Notification Sounds in app.json

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Add the expo-notifications plugin to your app.json and specify local paths to sound files under the 'sounds' key. These paths are relative to your project.

```json
{
  "expo": {
    "plugins": [
      [
        "expo-notifications",
        {
          "sounds": ["local/path/to/mySoundFile.wav"]
        }
      ]
    ]
  }
}
```

--------------------------------

### NotificationChannelInput

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Defines the structure for creating or updating a notification channel on Android. It includes essential properties like name and importance, along with audio attributes and sound settings.

```APIDOC
## NotificationChannelInput

### Description
Defines the structure for creating or updating a notification channel on Android. It includes essential properties like name and importance, along with audio attributes and sound settings.

### Type
RequiredBy<[Omit](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys)<[NotificationChannel](#notificationchannel), 'id' | 'audioAttributes' | 'sound'
> & { audioAttributes: [AudioAttributesInput](#audioattributesinput), sound: string | null }, 'name' | 'importance'

### Properties

- **name** (string) - Required - The name of the notification channel.
- **importance** (Importance) - Required - The importance level of the notification channel.
- **audioAttributes** (AudioAttributesInput) - Required - Audio attributes for the notification channel.
- **sound** (string | null) - Required - The sound to be played for the notification. Can be 'default' or a custom sound file path.
```

--------------------------------

### MonthlyTriggerInput

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Schedules a notification for monthly delivery on a specific day, hour, and minute. Supported on Android and iOS.

```APIDOC
## MonthlyTriggerInput

### Description
This trigger input will cause the notification to be delivered once per month when the `day`, `hour`, and `minute` date components match the specified values.

> **Note:** All properties are specified in JavaScript `Date` object's ranges (i.e. January is represented as 0).

### Parameters
#### Path Parameters
- **channelId** (string) - Optional - Description: -
- **day** (number) - Required - Description: -
- **hour** (number) - Required - Description: -
- **minute** (number) - Required - Description: -
- **type** (SchedulableTriggerInputTypes.MONTHLY) - Required - Description: -
```

--------------------------------

### Request Notification Permissions

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Prompts the user to grant notification permissions. You can optionally specify which types of permissions (alert, badge, sound) to request. The function returns a promise resolving to the updated permission status.

```typescript
import * as Notifications from 'expo-notifications';

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

--------------------------------

### NativeDevicePushToken

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Represents a native device push token for Android or iOS. Supported on both platforms.

```APIDOC
## NativeDevicePushToken

Supported platforms: Android, iOS.

### Properties
- **data** (string) - Description: The push token data.
- **type** ('ios' | 'android') - Description: The platform type of the token.
```

--------------------------------

### PermissionResponse

Source: https://docs.expo.dev/versions/latest/sdk/notifications

An object detailing the response of a permission request, including status and expiration.

```APIDOC
## PermissionResponse

Supported platforms: Android, iOS.

An object obtained by permissions get and request functions.

### Properties

- **canAskAgain** (`boolean`) - Indicates if user can be asked again for specific permission. If not, one should be directed to the Settings app in order to enable/disable the permission.
- **expires** (`PermissionExpiration`) - Determines time when the permission expires.
- **granted** (`boolean`) - A convenience boolean that indicates if the permission is granted.
- **status** ([PermissionStatus](#permissionstatus)) - Determines the status of the permission.
```

--------------------------------

### NotificationCategory

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Defines a group of notification actions and their behavior. Supported on both Android and iOS.

```APIDOC
## NotificationCategory

Supported platforms: Android, iOS.

Defines a group of notification actions and their behavior. Categories allow you to create custom action buttons that appear with notifications, enabling users to respond to notifications.

Categories must be registered with [`setNotificationCategoryAsync`](#notificationssetnotificationcategoryasyncidentifier-actions-options) before they can be used. When scheduling a notification, reference the category by its `identifier` in the [`NotificationContentInput.categoryIdentifier`](#notificationcontentinput) field.

### Properties
- **actions** (NotificationAction[]) - Description: An array of notification actions.
- **identifier** (string) - Description: The unique identifier for the category.
- **options** (optional) (NotificationCategoryOptions) - Description: Optional configuration options for the category.
```

--------------------------------

### Permission Status

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Represents the status of a notification permission request.

```javascript
PermissionStatus.DENIED = "denied"
```

```javascript
PermissionStatus.GRANTED = "granted"
```

```javascript
PermissionStatus.UNDETERMINED = "undetermined"
```

--------------------------------

### setNotificationChannelAsync

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Assigns configuration to a notification channel, creating it if it doesn't exist. Supports modifications to name and description on Android.

```APIDOC
## setNotificationChannelAsync(channelId, channel)

### Description
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.

> **Note:** After a channel has been created, you can modify only its name and description. This limitation is imposed by the Android OS.

### Method
`setNotificationChannelAsync`

### Parameters
#### Path Parameters
- **channelId** (string) - Required - The channel identifier.
#### Request Body
- **channel** ([NotificationChannelInput](#notificationchannelinput)) - Required - Object representing the channel's configuration.

### Response
#### Success Response (`notificationchannel` or `null`)
A Promise which resolves to the object describing the modified channel or `null` if the platform does not support notification channels.
```

--------------------------------

### Observe Notifications for Deep Linking

Source: https://docs.expo.dev/versions/latest/sdk/notifications

This hook listens for incoming and last notification responses to redirect the user to a specific URL defined in the notification data. It's designed to be used within a root layout component.

```tsx
import { useEffect } from 'react';
import * as Notifications from 'expo-notifications';
import { router } from 'expo-router';

function useNotificationObserver() {
  useEffect(() => {
    function redirect(notification: Notifications.Notification) {
      const url = notification.request.content.data?.url;
      if (typeof url === 'string') {
        router.push(url);
      }
    }

    const response = Notifications.getLastNotificationResponse();
    if (response?.notification) {
      redirect(response.notification);
    }

    const subscription = Notifications.addNotificationResponseReceivedListener(response => {
      redirect(response.notification);
    });

    return () => {
      subscription.remove();
    };
  }, []);
}

export default function Layout() {
  useNotificationObserver();

  return <Slot />;
}
```

--------------------------------

### Set Custom Notification Handler

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Use this function to define a callback that determines whether a notification should be displayed to the user when the app is running. The handler must respond within 3 seconds with a behavior object.

```jsx
import * as Notifications from 'expo-notifications';

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

--------------------------------

### DailyTriggerInput

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Schedules a notification for daily delivery at a specified hour and minute. Supported on Android and iOS.

```APIDOC
## DailyTriggerInput

### Description
This trigger input will cause the notification to be delivered once per day when the `hour` and `minute` date components match the specified values.

### Parameters
#### Path Parameters
- **channelId** (string) - Optional - Description: -
- **hour** (number) - Required - Description: -
- **minute** (number) - Required - Description: -
- **type** (SchedulableTriggerInputTypes.DAILY) - Required - Description: -
```

--------------------------------

### getPermissionsAsync

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Fetches the current notification permissions status for the app. This function checks if the app is allowed to display alerts, play sounds, or update the badge count without any user-facing effect.

```APIDOC
## getPermissionsAsync()

### Description
Supported platforms: Android, iOS. 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.

### Returns
`Promise<notificationpermissionsstatus>` - A Promise resolving to an object representing permission settings.
```

--------------------------------

### NotificationAction

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Defines an action that can be performed in response to a notification. Supported on both Android and iOS.

```APIDOC
## NotificationAction

Supported platforms: Android, iOS.

### Properties
- **buttonTitle** (string) - Description: The title of the button triggering this action.
- **identifier** (string) - Description: A unique string that identifies this action. If a user takes this action, your app will receive this `actionIdentifier` via the [`NotificationResponseReceivedListener`](#addnotificationresponsereceivedlistenerlistener).
- **options** (optional) ({ isAuthenticationRequired: boolean, isDestructive: boolean, opensAppToForeground: boolean }) - Description: Object representing the additional configuration options.
- **textInput** (optional) ({ placeholder: string, submitButtonTitle: string }) - Description: Object which, if provided, will result in a button that prompts the user for a text response.
```

--------------------------------

### iOS Alert Style

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Defines the alert style for iOS notifications.

```javascript
IosAlertStyle.NONE = 0
```

```javascript
IosAlertStyle.BANNER = 1
```

```javascript
IosAlertStyle.ALERT = 2
```

--------------------------------

### getNotificationChannelsAsync

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Fetches all known notification channels. Supported on Android.

```APIDOC
## getNotificationChannelsAsync()

### Description
Fetches information about all known notification channels.

### Method
`getNotificationChannelsAsync`

### Response
#### Success Response (`notificationchannel[]`)
A Promise which resolves to an array of channels. Returns an empty array on platforms without notification channel support.
```

--------------------------------

### NotificationBehavior

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Defines the behavior of an incoming notification. Supported on both Android and iOS.

```APIDOC
## NotificationBehavior

Supported platforms: Android, iOS.

An object which represents behavior that should be applied to the incoming notification. On Android, this influences whether the notification is shown, a sound is played, and priority. On iOS, this maps directly to [`UNNotificationPresentationOptions`](https://developer.apple.com/documentation/usernotifications/unnotificationpresentationoptions).

> On Android, setting `shouldPlaySound: false` will result in the drop-down notification alert **not** showing, no matter what the priority is. This setting will also override any channel-specific sounds you may have configured.

### Properties
- **priority** (optional) (AndroidNotificationPriority) - Description: The priority of the notification on Android.
- **shouldPlaySound** (boolean) - Description: Whether the notification should play a sound.
- **shouldSetBadge** (boolean) - Description: Supported platforms: iOS. Whether the notification should set the app badge.
- **shouldShowAlert** (optional) (boolean) - Description: Deprecated: instead, specify shouldShowBanner and / or shouldShowList.
- **shouldShowBanner** (boolean) - Description: Whether the notification should show a banner.
- **shouldShowList** (boolean) - Description: Whether the notification should show in the notification list.
```

--------------------------------

### NotificationResponse

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Represents a user's interaction with a notification, capturing the action taken and the associated notification details.

```APIDOC
## Type: NotificationResponse

### Description
An object representing a user's interaction with a notification.

### Properties
- **actionIdentifier** (string) - The identifier of the action performed by the user.
- **notification** ([Notification](#notification)) - The notification object that the user interacted with.
- **userText** (string, optional) - The text entered by the user, if applicable.
```

--------------------------------

### NotificationRequestInput

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Defines the structure for scheduling a new notification request, including content, an optional identifier, and trigger details.

```APIDOC
## Type: NotificationRequestInput

### Description
An object representing a notification request that can be passed to `scheduleNotificationAsync`.

### Properties
- **content** ([NotificationContentInput](#notificationcontentinput)) - The content of the notification.
- **identifier** (string, optional) - A unique identifier for the notification request.
- **trigger** ([NotificationTriggerInput](#notificationtriggerinput)) - The trigger for the notification.
```

--------------------------------

### NotificationContentAttachmentIos

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Defines the properties for visual and audio attachments in iOS notifications.

```APIDOC
## NotificationContentAttachmentIos

Supported platforms: iOS.

| Property | Type | Description |
| --- | --- | --- |
| hideThumbnail(optional) | `boolean` | - |
| identifier | `string | null` | - |
| thumbnailClipArea(optional) | `{ height: number, width: number, x: number, y: number }` | - |
| thumbnailTime(optional) | `number` | - |
| type | `string | null` | - |
| typeHint(optional) | `string` | - |
| url | `string | null` | -
```

--------------------------------

### getPresentedNotificationsAsync

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Fetches information about all notifications currently present in the notification tray.

```APIDOC
## getPresentedNotificationsAsync()

### Description
Fetches information about all notifications present in the notification tray (Notification Center).

### Method
Not applicable (JavaScript function)

### Parameters
None

### Request Example
```javascript
Notifications.getPresentedNotificationsAsync();
```

### Response
#### Success Response (200)
* **Promise<notification[]>** - A Promise which resolves with a list of notifications ([`Notification`](#notification)) currently 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.
```

--------------------------------

### NotificationPermissionsRequest

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Configures notification permissions requests for Android and iOS.

```APIDOC
## NotificationPermissionsRequest

### Description
An interface representing the permissions request scope configuration. Each option corresponds to a different native platform authorization option.

### Properties

- **`android`** (object, optional)
  - Description: On Android, all available permissions are granted by default, and if a user declines any permission, an app cannot prompt the user to change.

- **`ios`** ([IosNotificationPermissionsRequest](#iosnotificationpermissionsrequest), optional)
  - Description: Available configuration for permission request on iOS platform.
```

--------------------------------

### WeeklyTriggerInput

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Triggers a notification to be delivered once every week on a specified day and time.

```APIDOC
## WeeklyTriggerInput

### Description
This trigger input will cause the notification to be delivered once every week when the `weekday`, `hour`, and `minute` date components match the specified values.

> **Note:** Weekdays are specified with a number from `1` through `7`, with `1` indicating Sunday.

### Properties
- **channelId** (`string`, optional) - Description: -
- **hour** (`number`) - Description: -
- **minute** (`number`) - Description: -
- **type** (`SchedulableTriggerInputTypes.WEEKLY`) - Description: -
- **weekday** (`number`) - Description: -
```

--------------------------------

### getExpoPushTokenAsync

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Obtains an Expo push token that can be used to send notifications via Expo's push notification service. Handles potential network request failures.

```APIDOC
## getExpoPushTokenAsync(options?)

### Description
Retrieves a unique Expo push token for the device, which is necessary for sending notifications through Expo's push notification service. This method may fail due to network issues, so it's recommended to implement retry logic.

### Method
getExpoPushTokenAsync

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* **options** (ExpoPushTokenOptions) - Optional - An object to configure push notification settings. Defaults to an empty object.

### Returns
* **Promise<expopushtoken>** - A promise that resolves with an Expo push token.

### Example
```ts
import * as Notifications from 'expo-notifications';

export async function registerForPushNotificationsAsync(userId: string) {
  const expoPushToken = await Notifications.getExpoPushTokenAsync({
   projectId: 'your-project-id',
  });

  await fetch('https://example.com/', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      userId,
      expoPushToken,
    }),
  });
}
```
```

--------------------------------

### SchedulableNotificationTriggerInput

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Input for time-based, schedulable triggers. Supports various trigger types like date, time interval, daily, weekly, monthly, and yearly.

```APIDOC
## SchedulableNotificationTriggerInput

### Description
Input for time-based, schedulable triggers. You can check the next trigger date with `getNextTriggerDateAsync`. If a `number` (Unix timestamp) or `Date` is passed, it's treated as `SchedulableTriggerInputTypes.DATE`. Otherwise, an object with a `type` property is expected, set to one of the values in `SchedulableTriggerInputTypes`. Date components are validated for range.

### Type
`union`

### Acceptable Values
[CalendarTriggerInput](#calendartriggerinput) | [TimeIntervalTriggerInput](#timeintervaltriggerinput) | [DailyTriggerInput](#dailytriggerinput) | [WeeklyTriggerInput](#weeklytriggerinput) | [MonthlyTriggerInput](#monthlytriggerinput) | [YearlyTriggerInput](#yearlytriggerinput) | [DateTriggerInput](#datetriggerinput)

### Deprecated
Use the [`EventSubscription`](#eventsubscription) type instead.
```

--------------------------------

### PermissionExpiration

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Defines the expiration time for permissions, currently set to 'never'.

```APIDOC
## PermissionExpiration

Supported platforms: Android, iOS.

Literal Type: `union`

Permission expiration time. Currently, all permissions are granted permanently.

Acceptable values are: `'never'` | `number`
```

--------------------------------

### IosNotificationPermissionsRequest

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Configuration for requesting notification permissions on iOS.

```APIDOC
## IosNotificationPermissionsRequest

Supported platforms: iOS.

Available configuration for permission request on iOS platform. See Apple documentation for [`UNAuthorizationOptions`](https://developer.apple.com/documentation/usernotifications/unauthorizationoptions) to learn more.

### Properties
- **allowAlert** (boolean) - Optional - The ability to display alerts.
- **allowBadge** (boolean) - Optional - The ability to update the app’s badge.
- **allowCriticalAlerts** (boolean) - Optional - The ability to play sounds for critical alerts.
- **allowDisplayInCarPlay** (boolean) - Optional - The ability to display notifications in a CarPlay environment.
- **allowProvisional** (boolean) - Optional - The ability to post noninterrupting notifications provisionally to the Notification Center.
- **allowSound** (boolean) - Optional - The ability to play sounds.
- **provideAppNotificationSettings** (boolean) - Optional - An option indicating the system should display a button for in-app notification settings.
```

--------------------------------

### getNotificationCategoriesAsync

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Fetches information about all known notification categories. Supported on Android and iOS.

```APIDOC
## getNotificationCategoriesAsync()

### Description
Fetches information about all known notification categories.

### Method
Not applicable (SDK method)

### Endpoint
Not applicable (SDK method)

### Parameters
None

### Request Example
```javascript
Notifications.getNotificationCategoriesAsync();
```

### Response
#### Success Response
* **(notificationcategory[])** - An array of `NotificationCategory`s. On platforms that do not support notification channels, it will always resolve to an empty array.

### Response Example
```json
[
  {
    "identifier": "myCategoryIdentifier",
    "actions": [
      {
        "identifier": "reply",
        "buttonTitle": "Reply"
      }
    ]
  }
]
```
```

--------------------------------

### Notification

Source: https://docs.expo.dev/versions/latest/sdk/notifications

Represents a single notification that has been triggered. Supported on both Android and iOS.

```APIDOC
## Notification

Supported platforms: Android, iOS.

An object which represents a single notification that has been triggered by some request ([`NotificationRequest`](#notificationrequest)) at some point in time.

### Properties
- **date** (number) - Description: The timestamp when the notification was triggered.
- **request** (NotificationRequest) - Description: The notification request associated with this notification.
```