@amazon-devices/expo-notifications 2.0.9000000000-rn-83

package/src/NotificationsEmitter.ts

@@ -0,0 +1,111 @@
+import { EventEmitter, Subscription, UnavailabilityError } from 'expo-modules-core';
+
+import { Notification, NotificationResponse } from './Notifications.types';
+import NotificationsEmitterModule from './NotificationsEmitterModule';
+
+// Web uses SyntheticEventEmitter
+const emitter = new EventEmitter(NotificationsEmitterModule);
+
+const didReceiveNotificationEventName = 'onDidReceiveNotification';
+const didDropNotificationsEventName = 'onNotificationsDeleted';
+const didReceiveNotificationResponseEventName = 'onDidReceiveNotificationResponse';
+
+// @docsMissing
+export const DEFAULT_ACTION_IDENTIFIER = 'expo.modules.notifications.actions.DEFAULT';
+
+/**
+ * Listeners registered by this method will be called whenever a notification is received while the app is running.
+ * @param listener A function accepting a notification ([`Notification`](#notification)) as an argument.
+ * @return A [`Subscription`](#subscription) object represents the subscription of the provided listener.
+ * @example Registering a notification listener using a React hook:
+ * ```jsx
+ * import React from 'react';
+ * import * as Notifications from '@amazon-devices/expo-notifications';
+ *
+ * export default function App() {
+ *   React.useEffect(() => {
+ *     const subscription = Notifications.addNotificationReceivedListener(notification => {
+ *       console.log(notification);
+ *     });
+ *     return () => subscription.remove();
+ *   }, []);
+ *
+ *   return (
+ *     // Your app content
+ *   );
+ * }
+ * ```
+ * @header listen
+ */
+export function addNotificationReceivedListener(
+  listener: (event: Notification) => void
+): Subscription {
+  return emitter.addListener<Notification>(didReceiveNotificationEventName, listener);
+}
+
+/**
+ * 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 a notifications service on Android. It corresponds to `onDeletedMessages()` callback.
+ * More information can be found in [Firebase docs](https://firebase.google.com/docs/cloud-messaging/android/receive#override-ondeletedmessages).
+ * @param listener A callback function.
+ * @return A [`Subscription`](#subscription) object represents the subscription of the provided listener.
+ * @header listen
+ */
+export function addNotificationsDroppedListener(listener: () => void): Subscription {
+  return emitter.addListener<void>(didDropNotificationsEventName, listener);
+}
+
+/**
+ * Listeners registered by this method will be called whenever a user interacts with a notification (for example, taps on it).
+ * @param listener A function accepting notification response ([`NotificationResponse`](#notificationresponse)) as an argument.
+ * @return A [`Subscription`](#subscription) object represents the subscription of the provided listener.
+ * @example Register a notification responder listener:
+ * ```jsx
+ * import React from 'react';
+ * import { Linking } from 'react-native';
+ * import * as Notifications from '@amazon-devices/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
+ *   );
+ * }
+ * ```
+ * @header listen
+ */
+export function addNotificationResponseReceivedListener(
+  listener: (event: NotificationResponse) => void
+): Subscription {
+  return emitter.addListener<NotificationResponse>(
+    didReceiveNotificationResponseEventName,
+    listener
+  );
+}
+
+/**
+ * Removes a notification subscription returned by an `addNotificationListener` call.
+ * @param subscription A subscription returned by `addNotificationListener` method.
+ * @header listen
+ */
+export function removeNotificationSubscription(subscription: Subscription) {
+  emitter.removeSubscription(subscription);
+}
+
+// @docsMissing
+/**
+ * @header listen
+ */
+export async function getLastNotificationResponseAsync(): Promise<NotificationResponse | null> {
+  if (!NotificationsEmitterModule.getLastNotificationResponseAsync) {
+    throw new UnavailabilityError('ExpoNotifications', 'getLastNotificationResponseAsync');
+  }
+  return await NotificationsEmitterModule.getLastNotificationResponseAsync();
+}

package/src/NotificationsEmitterModule.kepler.ts

@@ -0,0 +1,8 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+export default {};

package/src/NotificationsEmitterModule.native.ts

@@ -0,0 +1,5 @@
+import { requireNativeModule } from 'expo-modules-core';
+
+import { NotificationsEmitterModule } from './NotificationsEmitterModule.types';
+
+export default requireNativeModule<NotificationsEmitterModule>('ExpoNotificationsEmitter');

package/src/NotificationsEmitterModule.ts

@@ -0,0 +1,17 @@
+import { Platform } from 'expo-modules-core';
+
+import { NotificationsEmitterModule } from './NotificationsEmitterModule.types';
+
+let warningHasBeenShown = false;
+
+export default {
+  addListener: () => {
+    if (!warningHasBeenShown) {
+      console.warn(
+        `[expo-notifications] Emitting notifications is not yet fully supported on ${Platform.OS}. Adding a listener will have no effect.`
+      );
+      warningHasBeenShown = true;
+    }
+  },
+  removeListeners: () => {},
+} as NotificationsEmitterModule;

package/src/NotificationsEmitterModule.types.ts

@@ -0,0 +1,7 @@
+import { ProxyNativeModule } from 'expo-modules-core';
+
+import { NotificationResponse } from './Notifications.types';
+
+export interface NotificationsEmitterModule extends ProxyNativeModule {
+  getLastNotificationResponseAsync?: () => Promise<NotificationResponse | null>;
+}

package/src/NotificationsHandler.ts

@@ -0,0 +1,120 @@
+import { EventEmitter, Subscription, CodedError, UnavailabilityError } from 'expo-modules-core';
+
+import { Notification, NotificationBehavior } from './Notifications.types';
+import NotificationsHandlerModule from './NotificationsHandlerModule';
+
+/**
+ * @hidden
+ */
+export class NotificationTimeoutError extends CodedError {
+  info: { notification: Notification; id: string };
+  constructor(notificationId: string, notification: Notification) {
+    super('ERR_NOTIFICATION_TIMEOUT', `Notification handling timed out for ID ${notificationId}.`);
+    this.info = { id: notificationId, notification };
+  }
+}
+
+// @docsMissing
+export type NotificationHandlingError = NotificationTimeoutError | Error;
+
+export interface NotificationHandler {
+  /**
+   * A function accepting an incoming notification returning a `Promise` resolving to a behavior ([`NotificationBehavior`](#notificationbehavior))
+   * applicable to the notification
+   * @param notification An object representing the notification.
+   */
+  handleNotification: (notification: Notification) => Promise<NotificationBehavior>;
+  /**
+   * A function called whenever an incoming notification is handled successfully.
+   * @param notificationId Identifier of the notification.
+   */
+  handleSuccess?: (notificationId: string) => void;
+  /**
+   * A function called whenever handling of an incoming notification fails.
+   * @param notificationId Identifier of the notification.
+   * @param error An error which occurred in form of `NotificationHandlingError` object.
+   */
+  handleError?: (notificationId: string, error: NotificationHandlingError) => void;
+}
+
+type HandleNotificationEvent = {
+  id: string;
+  notification: Notification;
+};
+
+type HandleNotificationTimeoutEvent = HandleNotificationEvent;
+
+// Web uses SyntheticEventEmitter
+const notificationEmitter = new EventEmitter(NotificationsHandlerModule);
+
+const handleNotificationEventName = 'onHandleNotification';
+const handleNotificationTimeoutEventName = 'onHandleNotificationTimeout';
+
+let handleSubscription: Subscription | null = null;
+let handleTimeoutSubscription: Subscription | null = null;
+
+/**
+ * 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.
+ * @param handler A single parameter which should be either `null` (if you want to clear the handler) or a [`NotificationHandler`](#notificationhandler) object.
+ *
+ * @example Implementing a notification handler that always shows the notification when it is received.
+ * ```jsx
+ * import * as Notifications from 'expo-notifications';
+ *
+ * Notifications.setNotificationHandler({
+ *   handleNotification: async () => ({
+ *     shouldShowAlert: true,
+ *     shouldPlaySound: false,
+ *     shouldSetBadge: false,
+ *   }),
+ * });
+ * ```
+ * @header inForeground
+ */
+export function setNotificationHandler(handler: NotificationHandler | null): void {
+  if (handleSubscription) {
+    handleSubscription.remove();
+    handleSubscription = null;
+  }
+  if (handleTimeoutSubscription) {
+    handleTimeoutSubscription.remove();
+    handleTimeoutSubscription = null;
+  }
+
+  if (handler) {
+    handleSubscription = notificationEmitter.addListener<HandleNotificationEvent>(
+      handleNotificationEventName,
+      async ({ id, notification }) => {
+        if (!NotificationsHandlerModule.handleNotificationAsync) {
+          handler.handleError?.(
+            id,
+            new UnavailabilityError('Notifications', 'handleNotificationAsync')
+          );
+          return;
+        }
+
+        try {
+          const behavior = await handler.handleNotification(notification);
+          await NotificationsHandlerModule.handleNotificationAsync(id, behavior);
+          handler.handleSuccess?.(id);
+        } catch (error) {
+          handler.handleError?.(id, error);
+        }
+      }
+    );
+
+    handleTimeoutSubscription = notificationEmitter.addListener<HandleNotificationTimeoutEvent>(
+      handleNotificationTimeoutEventName,
+      ({ id, notification }) =>
+        handler.handleError?.(id, new NotificationTimeoutError(id, notification))
+    );
+  }
+}

package/src/NotificationsHandlerModule.kepler.ts

@@ -0,0 +1,8 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+export default {};

package/src/NotificationsHandlerModule.native.ts

@@ -0,0 +1,5 @@
+import { requireNativeModule } from 'expo-modules-core';
+
+import { NotificationsHandlerModule } from './NotificationsHandlerModule.types';
+
+export default requireNativeModule<NotificationsHandlerModule>('ExpoNotificationsHandlerModule');

package/src/NotificationsHandlerModule.ts

@@ -0,0 +1,17 @@
+import { Platform } from 'expo-modules-core';
+
+import { NotificationsHandlerModule } from './NotificationsHandlerModule.types';
+
+let warningHasBeenShown = false;
+
+export default {
+  addListener: () => {
+    if (!warningHasBeenShown) {
+      console.warn(
+        `[expo-notifications] Notifications handling is not yet fully supported on ${Platform.OS}. Handling notifications will have no effect.`
+      );
+      warningHasBeenShown = true;
+    }
+  },
+  removeListeners: () => {},
+} as NotificationsHandlerModule;

package/src/NotificationsHandlerModule.types.ts

@@ -0,0 +1,10 @@
+import { ProxyNativeModule } from 'expo-modules-core';
+
+import { NotificationBehavior } from './Notifications.types';
+
+export interface NotificationsHandlerModule extends ProxyNativeModule {
+  handleNotificationAsync?: (
+    notificationId: string,
+    notificationBehavior: NotificationBehavior
+  ) => Promise<void>;
+}

package/src/PushTokenManager.kepler.ts

@@ -0,0 +1,8 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+export default {};

package/src/PushTokenManager.native.ts

@@ -0,0 +1,5 @@
+import { requireNativeModule } from 'expo-modules-core';
+
+import { PushTokenManagerModule } from './PushTokenManager.types';
+
+export default requireNativeModule<PushTokenManagerModule>('ExpoPushTokenManager');

package/src/PushTokenManager.ts

@@ -0,0 +1,17 @@
+import { Platform } from 'expo-modules-core';
+
+import { PushTokenManagerModule } from './PushTokenManager.types';
+
+let warningHasBeenShown = false;
+
+export default {
+  addListener: () => {
+    if (!warningHasBeenShown) {
+      console.warn(
+        `[expo-notifications] Listening to push token changes is not yet fully supported on ${Platform.OS}. Adding a listener will have no effect.`
+      );
+      warningHasBeenShown = true;
+    }
+  },
+  removeListeners: () => {},
+} as PushTokenManagerModule;

package/src/PushTokenManager.types.ts

@@ -0,0 +1,6 @@
+import { ProxyNativeModule } from 'expo-modules-core';
+
+export interface PushTokenManagerModule extends ProxyNativeModule {
+  getDevicePushTokenAsync?: () => Promise<string>;
+  unregisterForNotificationsAsync?: () => Promise<void>;
+}

package/src/ServerRegistrationModule.kepler.ts

@@ -0,0 +1,8 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+export default {};

package/src/ServerRegistrationModule.native.ts

@@ -0,0 +1,7 @@
+import { requireNativeModule } from 'expo-modules-core';
+
+import { ServerRegistrationModule } from './ServerRegistrationModule.types';
+
+export default requireNativeModule<ServerRegistrationModule>(
+  'NotificationsServerRegistrationModule'
+);

package/src/ServerRegistrationModule.ts

@@ -0,0 +1,6 @@
+import { ServerRegistrationModule } from './ServerRegistrationModule.types';
+
+export default {
+  addListener: () => {},
+  removeListeners: () => {},
+} as ServerRegistrationModule;

package/src/ServerRegistrationModule.types.ts

@@ -0,0 +1,7 @@
+import { ProxyNativeModule } from 'expo-modules-core';
+
+export interface ServerRegistrationModule extends ProxyNativeModule {
+  getInstallationIdAsync?: () => Promise<string>;
+  getRegistrationInfoAsync?: () => Promise<string | undefined | null>;
+  setRegistrationInfoAsync?: (registrationInfo: string | null) => Promise<void>;
+}

package/src/ServerRegistrationModule.web.ts

@@ -0,0 +1,56 @@
+import { CodedError, uuid } from 'expo-modules-core';
+
+import { ServerRegistrationModule } from './ServerRegistrationModule.types';
+
+const INSTALLATION_ID_KEY = 'EXPO_NOTIFICATIONS_INSTALLATION_ID';
+const REGISTRATION_INFO_KEY = 'EXPO_NOTIFICATIONS_REGISTRATION_INFO';
+
+// Lazy fallback installationId per session initializer
+let getFallbackInstallationId = () => {
+  const sessionInstallationId = uuid.v4();
+  getFallbackInstallationId = () => sessionInstallationId;
+};
+
+export default {
+  getInstallationIdAsync: async () => {
+    let installationId;
+
+    try {
+      installationId = localStorage.getItem(INSTALLATION_ID_KEY);
+      if (!installationId || typeof installationId !== 'string') {
+        installationId = uuid.v4();
+        localStorage.setItem(INSTALLATION_ID_KEY, installationId);
+      }
+    } catch {
+      installationId = getFallbackInstallationId();
+    }
+
+    return installationId;
+  },
+  getRegistrationInfoAsync: async () => {
+    if (typeof localStorage === 'undefined') {
+      return null;
+    }
+    return localStorage.getItem(REGISTRATION_INFO_KEY);
+  },
+  setRegistrationInfoAsync: async (registrationInfo: string | null) => {
+    if (typeof localStorage === 'undefined') {
+      return;
+    }
+    try {
+      if (registrationInfo) {
+        localStorage.setItem(REGISTRATION_INFO_KEY, registrationInfo);
+      } else {
+        localStorage.removeItem(REGISTRATION_INFO_KEY);
+      }
+    } catch (error) {
+      throw new CodedError(
+        'ERR_NOTIFICATIONS_STORAGE_ERROR',
+        `Could not modify localStorage to persist auto-registration information: ${error}`
+      );
+    }
+  },
+  // mock implementations
+  addListener: () => {},
+  removeListeners: () => {},
+} as ServerRegistrationModule;

package/src/TokenEmitter.ts

@@ -0,0 +1,56 @@
+import { EventEmitter, Subscription, Platform } from 'expo-modules-core';
+
+import PushTokenManager from './PushTokenManager';
+import { DevicePushToken } from './Tokens.types';
+
+/**
+ * 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.
+ * @header fetch
+ */
+export type PushTokenListener = (token: DevicePushToken) => void;
+
+// Web uses SyntheticEventEmitter
+const tokenEmitter = new EventEmitter(PushTokenManager);
+const newTokenEventName = 'onDevicePushToken';
+
+/**
+ * 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.
+ * @param listener A function accepting a push token as an argument, it will be called whenever the push token changes.
+ * @return A [`Subscription`](#subscription) object represents the subscription of the provided listener.
+ * @header fetch
+ * @example Registering a push token listener using a React hook.
+ * ```jsx
+ * import React from 'react';
+ * import * as Notifications from '@amazon-devices/expo-notifications';
+ *
+ * import { registerDevicePushTokenAsync } from '../api';
+ *
+ * export default function App() {
+ *   React.useEffect(() => {
+ *     const subscription = Notifications.addPushTokenListener(registerDevicePushTokenAsync);
+ *     return () => subscription.remove();
+ *   }, []);
+ *
+ *   return (
+ *     // Your app content
+ *   );
+ * }
+ * ```
+ */
+export function addPushTokenListener(listener: PushTokenListener): Subscription {
+  const wrappingListener = ({ devicePushToken }) =>
+    listener({ data: devicePushToken, type: Platform.OS });
+  return tokenEmitter.addListener(newTokenEventName, wrappingListener);
+}
+
+/**
+ * Removes a push token subscription returned by an `addPushTokenListener` call.
+ * @param subscription A subscription returned by `addPushTokenListener` method.
+ * @header fetch
+ */
+export function removePushTokenSubscription(subscription: Subscription) {
+  tokenEmitter.removeSubscription(subscription);
+}

package/src/Tokens.types.ts

@@ -0,0 +1,110 @@
+import { Platform } from 'expo-modules-core';
+
+// @docsMissing
+export interface NativeDevicePushToken {
+  type: 'ios' | 'android';
+  data: string;
+}
+
+// @docsMissing
+export interface WebDevicePushToken {
+  type: 'web';
+  data: {
+    endpoint: string;
+    keys: {
+      p256dh: string;
+      auth: string;
+    };
+  };
+}
+
+// @docsMissing
+type ExplicitlySupportedDevicePushToken = NativeDevicePushToken | WebDevicePushToken;
+
+type ImplicitlySupportedDevicePushToken = {
+  /**
+   * Either `android`, `ios` or `web`.
+   */
+  type: Exclude<typeof Platform.OS, ExplicitlySupportedDevicePushToken['type']>;
+  /**
+   * Either the push token as a string (when for native platforms), or an object conforming to the type below (for web):
+   * ```ts
+   * {
+   *   endpoint: string;
+   *   keys: {
+   *     p256dh: string;
+   *     auth: string;
+   *   }
+   * }
+   * ```
+   */
+  data: any;
+};
+
+/**
+ * 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 type DevicePushToken =
+  | ExplicitlySupportedDevicePushToken
+  | ImplicitlySupportedDevicePushToken;
+
+/**
+ * Borrowing structure from `DevicePushToken` a little. You can use the `data` value to send notifications via Expo Notifications service.
+ */
+export interface ExpoPushToken {
+  /**
+   * Always set to `"expo"`.
+   */
+  type: 'expo';
+  /**
+   * The acquired push token.
+   */
+  data: string;
+}
+
+export interface ExpoPushTokenOptions {
+  /**
+   * Endpoint URL override.
+   */
+  baseUrl?: string;
+  /**
+   * Request URL override.
+   */
+  url?: string;
+  /**
+   * Request body override.
+   */
+  type?: string;
+  // @missingDocs
+  deviceId?: string;
+  /**
+   * 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()`](./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.
+   * @platform ios
+   */
+  development?: boolean;
+  /**
+   * The ID of the project to which the token should be attributed.
+   * Defaults to [`Constants.expoConfig.extra.eas.projectId`](./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`](./constants/#manifest).
+   */
+  projectId?: string;
+  /**
+   * The ID of the application to which the token should be attributed.
+   * Defaults to [`Application.applicationId`](./application/#applicationapplicationid) exposed by `expo-application`.
+   */
+  applicationId?: string;
+  /**
+   * The device push token with which to register at the backend.
+   * Defaults to a token fetched with [`getDevicePushTokenAsync()`](#getdevicepushtokenasync).
+   */
+  devicePushToken?: DevicePushToken;
+}

package/src/cancelAllScheduledNotificationsAsync.ts

@@ -0,0 +1,16 @@
+import { UnavailabilityError } from 'expo-modules-core';
+
+import NotificationScheduler from './NotificationScheduler';
+
+/**
+ * Cancels all scheduled notifications.
+ * @return A Promise that resolves once all the scheduled notifications are successfully canceled, or if there are no scheduled notifications.
+ * @header schedule
+ */
+export default async function cancelAllScheduledNotificationsAsync(): Promise<void> {
+  if (!NotificationScheduler.cancelAllScheduledNotificationsAsync) {
+    throw new UnavailabilityError('Notifications', 'cancelAllScheduledNotificationsAsync');
+  }
+
+  return await NotificationScheduler.cancelAllScheduledNotificationsAsync();
+}

package/src/cancelScheduledNotificationAsync.ts

@@ -0,0 +1,31 @@
+import { UnavailabilityError } from 'expo-modules-core';
+
+import NotificationScheduler from './NotificationScheduler';
+
+/**
+ * Cancels a single scheduled notification. The scheduled notification of given ID will not trigger.
+ * @param identifier The notification identifier with which `scheduleNotificationAsync` method resolved when the notification has been scheduled.
+ * @return A Promise resolves once the scheduled notification is successfully canceled or if there is no scheduled notification for a given identifier.
+ * @example Schedule and then cancel the notification:
+ * ```ts
+ * import * as Notifications from '@amazon-devices/expo-notifications';
+ *
+ * async function scheduleAndCancel() {
+ *   const identifier = await Notifications.scheduleNotificationAsync({
+ *     content: {
+ *       title: 'Hey!',
+ *     },
+ *     trigger: { seconds: 60, repeats: true },
+ *   });
+ *   await Notifications.cancelScheduledNotificationAsync(identifier);
+ * }
+ * ```
+ * @header schedule
+ */
+export default async function cancelScheduledNotificationAsync(identifier: string): Promise<void> {
+  if (!NotificationScheduler.cancelScheduledNotificationAsync) {
+    throw new UnavailabilityError('Notifications', 'cancelScheduledNotificationAsync');
+  }
+
+  return await NotificationScheduler.cancelScheduledNotificationAsync(identifier);
+}