@ng-native/expo 0.0.1 → 0.1.0

package/dist/native.js

@@ -0,0 +1,73 @@
+/**
+ * Reaching an Expo module without importing one.
+ *
+ * A static `import ... from 'expo-battery'` makes the file unloadable by Node, which is what used
+ * to force every service into two files: the behaviour somewhere the test suite could reach, and
+ * the binding somewhere it could not. A `require` inside a function has neither problem. Metro
+ * still resolves the string literal at build time, so the module is bundled exactly as before and
+ * an app that has not installed it still gets a build error rather than a surprise at runtime;
+ * Node never evaluates the call at all, because nothing in a test asks for the real platform.
+ *
+ * The `catch` is doing two jobs, and only one of them is Node. In an ESM test `require` is not
+ * defined, so calling it throws `ReferenceError` and the service goes inert - the same state as
+ * a device that has no such sensor. On a device the throw is a module that is present but not
+ * linked, which is the same answer for the same reason.
+ */
+export function optional(load) {
+    try {
+        return load();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * A module the app needs and does not have: the package is not installed, or it is and the app was
+ * not rebuilt since, so its native half is not in the binary. Development builds and Expo Go carry
+ * only the native modules they were built with.
+ */
+export class MissingModuleError extends Error {
+    name = 'MissingModuleError';
+    /** The package, as it is installed: `expo-haptics`. */
+    module;
+    constructor(module, platform, cause) {
+        super(platform === 'web'
+            ? `${module} is not installed. Install it with "npx expo install ${module}", then restart the dev server.`
+            : `${module} is not in this build of the app. Install it with "npx expo install ${module}", ` +
+                `then rebuild the app ("npx expo run:${platform}", or a new EAS build): a development ` +
+                `build, and Expo Go, contain only the native modules they were built with.`, { cause });
+        this.module = module;
+    }
+}
+/** The platform the app is running on, or null in Node, where there is none to ask. */
+function currentPlatform() {
+    return optional(() => require('react-native').Platform.OS);
+}
+/**
+ * The Expo module a service needs.
+ *
+ * Where the module exists for the platform the app is on, a module that is missing is a mistake
+ * the developer can fix, so this throws a `MissingModuleError` that says how - rather than leave a
+ * feature that silently does nothing. Anywhere it cannot exist - an iOS-only module on Android, the
+ * web, and Node, where a test runs with no platform at all - this answers null, and the service
+ * goes inert, as code shared across platforms needs it to.
+ *
+ * `load` answering null or undefined counts as missing too: `requireOptionalNativeModule` answers
+ * null rather than throwing.
+ */
+export function expoModule(module, load, platforms = ['ios', 'android']) {
+    let failure;
+    try {
+        const loaded = load();
+        if (loaded != null)
+            return loaded;
+    }
+    catch (error) {
+        failure = error;
+    }
+    const platform = currentPlatform();
+    if (platform === null || !platforms.includes(platform))
+        return null;
+    throw new MissingModuleError(module, platform, failure);
+}
+//# sourceMappingURL=native.js.map

package/dist/native.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native.js","sourceRoot":"","sources":["../src/native.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,QAAQ,CAAI,IAAa;IACvC,IAAI,CAAC;QACH,OAAO,IAAI,EAAE,CAAC;IAChB,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAKD;;;;GAIG;AACH,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IACzB,IAAI,GAAG,oBAAoB,CAAC;IAC9C,uDAAuD;IAC9C,MAAM,CAAS;IAExB,YAAY,MAAc,EAAE,QAAwB,EAAE,KAAe;QACnE,KAAK,CACH,QAAQ,KAAK,KAAK;YAChB,CAAC,CAAC,GAAG,MAAM,wDAAwD,MAAM,iCAAiC;YAC1G,CAAC,CAAC,GAAG,MAAM,uEAAuE,MAAM,KAAK;gBACzF,uCAAuC,QAAQ,wCAAwC;gBACvF,2EAA2E,EACjF,EAAE,KAAK,EAAE,CACV,CAAC;QACF,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;CACF;AAED,uFAAuF;AACvF,SAAS,eAAe;IACtB,OAAO,QAAQ,CACb,GAAG,EAAE,CAAE,OAAO,CAAC,cAAc,CAAkC,CAAC,QAAQ,CAAC,EAAoB,CAC9F,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,UAAU,CACxB,MAAc,EACd,IAAgC,EAChC,YAAuC,CAAC,KAAK,EAAE,SAAS,CAAC;IAEzD,IAAI,OAAgB,CAAC;IACrB,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,IAAI,EAAE,CAAC;QACtB,IAAI,MAAM,IAAI,IAAI;YAAE,OAAO,MAAM,CAAC;IACpC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,GAAG,KAAK,CAAC;IAClB,CAAC;IACD,MAAM,QAAQ,GAAG,eAAe,EAAE,CAAC;IACnC,IAAI,QAAQ,KAAK,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAAE,OAAO,IAAI,CAAC;IACpE,MAAM,IAAI,kBAAkB,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;AAC1D,CAAC","sourcesContent":["/**\n * Reaching an Expo module without importing one.\n *\n * A static `import ... from 'expo-battery'` makes the file unloadable by Node, which is what used\n * to force every service into two files: the behaviour somewhere the test suite could reach, and\n * the binding somewhere it could not. A `require` inside a function has neither problem. Metro\n * still resolves the string literal at build time, so the module is bundled exactly as before and\n * an app that has not installed it still gets a build error rather than a surprise at runtime;\n * Node never evaluates the call at all, because nothing in a test asks for the real platform.\n *\n * The `catch` is doing two jobs, and only one of them is Node. In an ESM test `require` is not\n * defined, so calling it throws `ReferenceError` and the service goes inert - the same state as\n * a device that has no such sensor. On a device the throw is a module that is present but not\n * linked, which is the same answer for the same reason.\n */\nexport function optional<T>(load: () => T): T | null {\n  try {\n    return load();\n  } catch {\n    return null;\n  }\n}\n\n/** The platforms an Expo module is written for. */\nexport type ModulePlatform = 'ios' | 'android' | 'web';\n\n/**\n * A module the app needs and does not have: the package is not installed, or it is and the app was\n * not rebuilt since, so its native half is not in the binary. Development builds and Expo Go carry\n * only the native modules they were built with.\n */\nexport class MissingModuleError extends Error {\n  override readonly name = 'MissingModuleError';\n  /** The package, as it is installed: `expo-haptics`. */\n  readonly module: string;\n\n  constructor(module: string, platform: ModulePlatform, cause?: unknown) {\n    super(\n      platform === 'web'\n        ? `${module} is not installed. Install it with \"npx expo install ${module}\", then restart the dev server.`\n        : `${module} is not in this build of the app. Install it with \"npx expo install ${module}\", ` +\n            `then rebuild the app (\"npx expo run:${platform}\", or a new EAS build): a development ` +\n            `build, and Expo Go, contain only the native modules they were built with.`,\n      { cause },\n    );\n    this.module = module;\n  }\n}\n\n/** The platform the app is running on, or null in Node, where there is none to ask. */\nfunction currentPlatform(): ModulePlatform | null {\n  return optional(\n    () => (require('react-native') as { Platform: { OS: string } }).Platform.OS as ModulePlatform,\n  );\n}\n\n/**\n * The Expo module a service needs.\n *\n * Where the module exists for the platform the app is on, a module that is missing is a mistake\n * the developer can fix, so this throws a `MissingModuleError` that says how - rather than leave a\n * feature that silently does nothing. Anywhere it cannot exist - an iOS-only module on Android, the\n * web, and Node, where a test runs with no platform at all - this answers null, and the service\n * goes inert, as code shared across platforms needs it to.\n *\n * `load` answering null or undefined counts as missing too: `requireOptionalNativeModule` answers\n * null rather than throwing.\n */\nexport function expoModule<T>(\n  module: string,\n  load: () => T | null | undefined,\n  platforms: readonly ModulePlatform[] = ['ios', 'android'],\n): T | null {\n  let failure: unknown;\n  try {\n    const loaded = load();\n    if (loaded != null) return loaded;\n  } catch (error) {\n    failure = error;\n  }\n  const platform = currentPlatform();\n  if (platform === null || !platforms.includes(platform)) return null;\n  throw new MissingModuleError(module, platform, failure);\n}\n"]}

package/dist/network.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `Network`, bound to `expo-network`.
+ *
+ * Whether the app can reach anything, which is not the same as whether it has a connection. A
+ * phone on a captive-portal wifi is connected and reachable by nothing; a phone in a lift has a
+ * connection type and no signal. `reachable` is the one worth branching on, and it is the one the
+ * platform is least sure about - it stays `null` until something has actually been reached.
+ */
+import { InjectionToken, type Signal } from '@angular/core';
+import { type Observed } from './observed.ts';
+import * as i0 from "@angular/core";
+export type ConnectionType = 'wifi' | 'cellular' | 'ethernet' | 'bluetooth' | 'vpn' | 'other' | 'none' | 'unknown';
+export interface NetworkStatus {
+    readonly connected: boolean;
+    readonly type: ConnectionType;
+    /** Null while the platform has not established it, which is not the same as false. */
+    readonly reachable: boolean | null;
+}
+export declare const OFFLINE: NetworkStatus;
+export declare class Network {
+    /** Overridden in a test to go offline without a network. */
+    static readonly SOURCE: InjectionToken<Observed<NetworkStatus> | null>;
+    readonly status: Signal<NetworkStatus>;
+    /** Whether there is a connection of any kind. Say what you mean: this is not reachability. */
+    readonly connected: Signal<boolean>;
+    /** What the connection is over, for a screen that offers to wait for wifi. */
+    readonly type: Signal<ConnectionType>;
+    /**
+     * Whether anything has actually been reached. Null until the platform knows, so a screen that
+     * shows an offline banner should treat null as "not yet" rather than as offline.
+     */
+    readonly reachable: Signal<boolean | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Network, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}

package/dist/network.js

@@ -0,0 +1,60 @@
+/**
+ * `Network`, bound to `expo-network`.
+ *
+ * Whether the app can reach anything, which is not the same as whether it has a connection. A
+ * phone on a captive-portal wifi is connected and reachable by nothing; a phone in a lift has a
+ * connection type and no signal. `reachable` is the one worth branching on, and it is the one the
+ * platform is least sure about - it stays `null` until something has actually been reached.
+ */
+import { InjectionToken, Service, computed, inject } from '@angular/core';
+import { observed, observedFrom } from "./observed.js";
+import { expoModule } from "./native.js";
+import * as i0 from "@angular/core";
+export const OFFLINE = { connected: false, type: 'unknown', reachable: null };
+const TYPES = {
+    NONE: 'none',
+    UNKNOWN: 'unknown',
+    WIFI: 'wifi',
+    CELLULAR: 'cellular',
+    BLUETOOTH: 'bluetooth',
+    ETHERNET: 'ethernet',
+    VPN: 'vpn',
+    OTHER: 'other',
+};
+export class Network {
+    /** Overridden in a test to go offline without a network. */
+    static SOURCE = new InjectionToken('angular-native.networkSource', {
+        factory: () => {
+            const expo = expoModule('expo-network', () => require('expo-network'));
+            if (!expo)
+                return null;
+            const read = (state) => ({
+                connected: state.isConnected ?? false,
+                type: TYPES[state.type ?? 'UNKNOWN'] ?? 'unknown',
+                // `undefined` means the platform has not established it; `null` is how that is said here,
+                // so a consumer cannot confuse "not yet" with "no".
+                reachable: state.isInternetReachable ?? null,
+            });
+            return observedFrom(async () => read(await expo.getNetworkStateAsync()), (listener) => expo.addNetworkStateListener((event) => listener(read(event))));
+        },
+    });
+    status = observed(inject(Network.SOURCE), OFFLINE);
+    /** Whether there is a connection of any kind. Say what you mean: this is not reachability. */
+    connected = computed(() => this.status().connected, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "connected" }] : /* istanbul ignore next */ []));
+    /** What the connection is over, for a screen that offers to wait for wifi. */
+    type = computed(() => this.status().type, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "type" }] : /* istanbul ignore next */ []));
+    /**
+     * Whether anything has actually been reached. Null until the platform knows, so a screen that
+     * shows an offline banner should treat null as "not yet" rather than as offline.
+     */
+    reachable = computed(() => this.status().reachable, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "reachable" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Network, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.2.0", ngImport: i0, type: Network });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Network, decorators: [{
+            type: Service
+        }] });
+//# sourceMappingURL=network.js.map

package/dist/network.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"network.js","sourceRoot":"","sources":["../src/network.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAe,MAAM,eAAe,CAAC;AACvF,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAiB,MAAM,eAAe,CAAC;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;;AAYzC,MAAM,CAAC,MAAM,OAAO,GAAkB,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;AAE7F,MAAM,KAAK,GAAmC;IAC5C,IAAI,EAAE,MAAM;IACZ,OAAO,EAAE,SAAS;IAClB,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,UAAU;IACpB,SAAS,EAAE,WAAW;IACtB,QAAQ,EAAE,UAAU;IACpB,GAAG,EAAE,KAAK;IACV,KAAK,EAAE,OAAO;CACf,CAAC;AAGF,MAAM,OAAO,OAAO;IAClB,4DAA4D;IAC5D,MAAM,CAAU,MAAM,GAAG,IAAI,cAAc,CACzC,8BAA8B,EAC9B;QACE,OAAO,EAAE,GAAG,EAAE;YACZ,MAAM,IAAI,GAAG,UAAU,CACrB,cAAc,EACd,GAAG,EAAE,CAAC,OAAO,CAAC,cAAc,CAAkC,CAC/D,CAAC;YACF,IAAI,CAAC,IAAI;gBAAE,OAAO,IAAI,CAAC;YAEvB,MAAM,IAAI,GAAG,CACX,KAAqF,EACtE,EAAE,CAAC,CAAC;gBACnB,SAAS,EAAE,KAAK,CAAC,WAAW,IAAI,KAAK;gBACrC,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,IAAI,SAAS,CAAC,IAAI,SAAS;gBACjD,0FAA0F;gBAC1F,oDAAoD;gBACpD,SAAS,EAAE,KAAK,CAAC,mBAAmB,IAAI,IAAI;aAC7C,CAAC,CAAC;YAEH,OAAO,YAAY,CACjB,KAAK,IAAI,EAAE,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,oBAAoB,EAAE,CAAC,EACnD,CAAC,QAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAC7E,CAAC;QACJ,CAAC;KACF,CACF,CAAC;IAEO,MAAM,GAA0B,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC;IAEnF,8FAA8F;IACrF,SAAS,GAAoB,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,SAAS;kFAAC,CAAC;IAE9E,8EAA8E;IACrE,IAAI,GAA2B,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,IAAI;6EAAC,CAAC;IAE3E;;;OAGG;IACM,SAAS,GAA2B,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,SAAS;kFAAC,CAAC;uGA1C1E,OAAO;wGAAP,OAAO;;2FAAP,OAAO;kBADnB,OAAO","sourcesContent":["/**\n * `Network`, bound to `expo-network`.\n *\n * Whether the app can reach anything, which is not the same as whether it has a connection. A\n * phone on a captive-portal wifi is connected and reachable by nothing; a phone in a lift has a\n * connection type and no signal. `reachable` is the one worth branching on, and it is the one the\n * platform is least sure about - it stays `null` until something has actually been reached.\n */\nimport { InjectionToken, Service, computed, inject, type Signal } from '@angular/core';\nimport { observed, observedFrom, type Observed } from './observed.ts';\nimport { expoModule } from './native.ts';\n\nexport type ConnectionType =\n  'wifi' | 'cellular' | 'ethernet' | 'bluetooth' | 'vpn' | 'other' | 'none' | 'unknown';\n\nexport interface NetworkStatus {\n  readonly connected: boolean;\n  readonly type: ConnectionType;\n  /** Null while the platform has not established it, which is not the same as false. */\n  readonly reachable: boolean | null;\n}\n\nexport const OFFLINE: NetworkStatus = { connected: false, type: 'unknown', reachable: null };\n\nconst TYPES: Record<string, ConnectionType> = {\n  NONE: 'none',\n  UNKNOWN: 'unknown',\n  WIFI: 'wifi',\n  CELLULAR: 'cellular',\n  BLUETOOTH: 'bluetooth',\n  ETHERNET: 'ethernet',\n  VPN: 'vpn',\n  OTHER: 'other',\n};\n\n@Service()\nexport class Network {\n  /** Overridden in a test to go offline without a network. */\n  static readonly SOURCE = new InjectionToken<Observed<NetworkStatus> | null>(\n    'angular-native.networkSource',\n    {\n      factory: () => {\n        const expo = expoModule(\n          'expo-network',\n          () => require('expo-network') as typeof import('expo-network'),\n        );\n        if (!expo) return null;\n\n        const read = (\n          state: import('expo-network').NetworkState | import('expo-network').NetworkStateEvent,\n        ): NetworkStatus => ({\n          connected: state.isConnected ?? false,\n          type: TYPES[state.type ?? 'UNKNOWN'] ?? 'unknown',\n          // `undefined` means the platform has not established it; `null` is how that is said here,\n          // so a consumer cannot confuse \"not yet\" with \"no\".\n          reachable: state.isInternetReachable ?? null,\n        });\n\n        return observedFrom(\n          async () => read(await expo.getNetworkStateAsync()),\n          (listener) => expo.addNetworkStateListener((event) => listener(read(event))),\n        );\n      },\n    },\n  );\n\n  readonly status: Signal<NetworkStatus> = observed(inject(Network.SOURCE), OFFLINE);\n\n  /** Whether there is a connection of any kind. Say what you mean: this is not reachability. */\n  readonly connected: Signal<boolean> = computed(() => this.status().connected);\n\n  /** What the connection is over, for a screen that offers to wait for wifi. */\n  readonly type: Signal<ConnectionType> = computed(() => this.status().type);\n\n  /**\n   * Whether anything has actually been reached. Null until the platform knows, so a screen that\n   * shows an offline banner should treat null as \"not yet\" rather than as offline.\n   */\n  readonly reachable: Signal<boolean | null> = computed(() => this.status().reachable);\n}\n"]}

package/dist/notifications.d.ts

@@ -0,0 +1,175 @@
+/**
+ * `Notifications`, bound to `expo-notifications`: everything the module does, as one injectable
+ * service.
+ *
+ * ```ts
+ * import { Notifications, TriggerType } from '@ng-native/expo/notifications';
+ *
+ * private readonly notifications = inject(Notifications);
+ *
+ * async remind(): Promise<void> {
+ *   if (!(await this.notifications.permission.ensure())) return;
+ *   await this.notifications.schedule({
+ *     content: { title: 'Time to stretch' },
+ *     trigger: { type: TriggerType.DAILY, hour: 9, minute: 0 },
+ *   });
+ * }
+ *
+ * constructor() {
+ *   const tapped = this.notifications.take();
+ *   if (tapped) this.router.navigateByUrl(routeFor(tapped));
+ * }
+ * ```
+ *
+ * The listeners are the part a hook used to be the only way to reach, and they are signals here.
+ * *Received* is a notification arriving while the app is in front; the app usually decides whether
+ * to show anything. *Responded* is the user having tapped one, which is a navigation instruction
+ * and must not be missed - including the one that launched the app, which arrived before anything
+ * was listening.
+ *
+ * The rest - permission, scheduling, what is on screen, the badge, Android's channels, the action
+ * buttons of categories, the foreground handler, push tokens and topics, background tasks - is the
+ * module's own functions under shorter names, with its own types. Without the module installed,
+ * or in a test that provides nothing, every query answers empty and every change does nothing.
+ * The push token methods ask for the permission first, since a token nobody can be shown anything
+ * with fails silently: the push simply never arrives.
+ */
+import { InjectionToken, type Signal } from '@angular/core';
+import type { DevicePushToken, Notification, NotificationResponse, SchedulableTriggerInputTypes } from 'expo-notifications';
+import { Permission } from './permissions.ts';
+import * as i0 from "@angular/core";
+type Expo = typeof import('expo-notifications');
+/**
+ * The module's functions this service calls. The real module is one; a test provides a fake that
+ * delivers notifications nobody sent.
+ */
+export type NativeNotifications = Pick<Expo, 'addNotificationReceivedListener' | 'addNotificationResponseReceivedListener' | 'addNotificationsDroppedListener' | 'addPushTokenListener' | 'getLastNotificationResponseAsync' | 'clearLastNotificationResponseAsync' | 'getPermissionsAsync' | 'requestPermissionsAsync' | 'scheduleNotificationAsync' | 'cancelScheduledNotificationAsync' | 'cancelAllScheduledNotificationsAsync' | 'getAllScheduledNotificationsAsync' | 'getNextTriggerDateAsync' | 'getPresentedNotificationsAsync' | 'dismissNotificationAsync' | 'dismissAllNotificationsAsync' | 'getBadgeCountAsync' | 'setBadgeCountAsync' | 'getNotificationChannelsAsync' | 'getNotificationChannelAsync' | 'setNotificationChannelAsync' | 'deleteNotificationChannelAsync' | 'getNotificationChannelGroupsAsync' | 'getNotificationChannelGroupAsync' | 'setNotificationChannelGroupAsync' | 'deleteNotificationChannelGroupAsync' | 'getNotificationCategoriesAsync' | 'setNotificationCategoryAsync' | 'deleteNotificationCategoryAsync' | 'setNotificationHandler' | 'getExpoPushTokenAsync' | 'getDevicePushTokenAsync' | 'unregisterForNotificationsAsync' | 'setAutoServerRegistrationEnabledAsync' | 'subscribeToTopicAsync' | 'unsubscribeFromTopicAsync' | 'registerTaskAsync' | 'unregisterTaskAsync'>;
+type Args<K extends keyof NativeNotifications> = Parameters<NativeNotifications[K]>;
+/**
+ * The kinds of trigger a schedule takes, as `expo-notifications`' own enum. Importing the enum
+ * from the module loads the module, which a test in Node cannot; these are the same strings,
+ * typed as the enum, so `{ type: TriggerType.DAILY, hour: 9, minute: 0 }` is accepted either way.
+ */
+export declare const TriggerType: typeof SchedulableTriggerInputTypes;
+export declare class Notifications {
+    /** Overridden in a test to deliver a notification nobody sent. */
+    static readonly SOURCE: InjectionToken<NativeNotifications | null>;
+    private readonly native;
+    private readonly received;
+    private readonly responded;
+    private readonly rolled;
+    private readonly drops;
+    private readonly handled;
+    /**
+     * The permission to show notifications. `ensure()` asks only if it has not been answered; for
+     * iOS's finer options (provisional, critical alerts), use {@link requestPermission}.
+     */
+    readonly permission: Permission;
+    constructor();
+    /** The most recent notification that arrived while the app was in front. */
+    readonly latest: Signal<Notification | null>;
+    /**
+     * The most recent notification the user tapped, including the one that launched the app.
+     *
+     * A router usually wants `take()` instead: this stays set, so a screen that reacts to it will
+     * react again every time it is created.
+     */
+    readonly response: Signal<NotificationResponse | null>;
+    /**
+     * The response, once.
+     *
+     * Routing on a tap is a one-off, and the signal is not: an effect on it fires again whenever
+     * its component is recreated, which sends the user back to a screen they navigated away from.
+     */
+    take(): NotificationResponse | null;
+    /** Forgets the tap, here and in the module, so the next launch does not see it again. */
+    clearResponse(): Promise<void>;
+    /** How many times Android has reported notifications dropped. Zero on iOS. */
+    readonly dropped: Signal<number>;
+    /** Asks with iOS's finer options. The answer also updates {@link permission}. */
+    requestPermission(...options: Args<'requestPermissionsAsync'>): Promise<boolean>;
+    /** Schedules a local notification, or shows it now with a null trigger. Null without the module. */
+    schedule(...request: Args<'scheduleNotificationAsync'>): Promise<string | null>;
+    cancel(identifier: string): Promise<void>;
+    cancelAll(): Promise<void>;
+    /** Every local notification still waiting for its trigger. */
+    scheduled(): Promise<Awaited<ReturnType<Expo['getAllScheduledNotificationsAsync']>>>;
+    /** When a trigger would next fire, in milliseconds since the epoch; null if it never will. */
+    nextTriggerDate(...trigger: Args<'getNextTriggerDateAsync'>): Promise<number | null>;
+    /** The notifications in the notification centre that are the app's. */
+    presented(): Promise<Notification[]>;
+    dismiss(identifier: string): Promise<void>;
+    /** Clears every notification the app has on screen. A failure is ignored. */
+    dismissAll(): void;
+    badge(): Promise<number>;
+    /**
+     * iOS shows this on the icon; Android shows it where the launcher supports it. A failure is
+     * ignored.
+     */
+    setBadge(count: number): void;
+    /** Android's notification channels. Empty on iOS, which has none. */
+    channels(): Promise<Awaited<ReturnType<Expo['getNotificationChannelsAsync']>>>;
+    channel(identifier: string): Promise<Awaited<ReturnType<Expo['getNotificationChannelAsync']>>>;
+    /**
+     * Creates or updates an Android channel; a notification on Android 8 and later needs one to
+     * show at all. Null on iOS.
+     */
+    setChannel(...channel: Args<'setNotificationChannelAsync'>): Promise<Awaited<ReturnType<Expo['setNotificationChannelAsync']>>>;
+    deleteChannel(identifier: string): Promise<void>;
+    channelGroups(): Promise<Awaited<ReturnType<Expo['getNotificationChannelGroupsAsync']>>>;
+    channelGroup(identifier: string): Promise<Awaited<ReturnType<Expo['getNotificationChannelGroupAsync']>>>;
+    setChannelGroup(...group: Args<'setNotificationChannelGroupAsync'>): Promise<Awaited<ReturnType<Expo['setNotificationChannelGroupAsync']>>>;
+    deleteChannelGroup(identifier: string): Promise<void>;
+    /** The categories set: each a set of action buttons a notification opts into. */
+    categories(): Promise<Awaited<ReturnType<Expo['getNotificationCategoriesAsync']>>>;
+    /**
+     * Action buttons for notifications whose content names this category. A tap on one arrives as
+     * a response with the button's identifier, and the typed text as `userText` for a text input.
+     */
+    setCategory(...category: Args<'setNotificationCategoryAsync'>): Promise<Awaited<ReturnType<Expo['setNotificationCategoryAsync']>> | null>;
+    deleteCategory(identifier: string): Promise<boolean>;
+    /**
+     * What a notification that arrives while the app is in front does: shown, silent, with a sound
+     * or a badge. Without a handler, it is not shown. Null removes the handler.
+     */
+    setHandler(...handler: Args<'setNotificationHandler'>): void;
+    /**
+     * The token to hand a backend so it can send a push through Expo's service.
+     *
+     * Asks for the notification permission first - a token nobody can be shown anything with is not
+     * worth having. `projectId` defaults to the app's own EAS project; pass it explicitly for a bare
+     * workflow app, one still without EAS Build configured, or a token fetched outside
+     * `expo-notifications`' default resolution. Null without the permission or without the module.
+     */
+    getExpoPushToken(projectId?: string): Promise<string | null>;
+    /**
+     * The raw APNs (iOS) or FCM (Android) token, for a backend that talks to those services
+     * directly rather than through Expo's push service. Same permission and module rules as
+     * {@link getExpoPushToken}.
+     */
+    getDevicePushToken(): Promise<DevicePushToken | null>;
+    /**
+     * The device push token, each time the platform rolls it while the app is running.
+     *
+     * A rolled token is not the one a backend has on file, and sending to the old one fails
+     * silently - this is what tells an app to register the new one. Unset until a roll happens;
+     * most of an app's life this stays null.
+     */
+    readonly devicePushToken: Signal<DevicePushToken | null>;
+    /** Stops the device receiving pushes until a token is asked for again. */
+    unregister(): Promise<void>;
+    /** Whether Expo re-registers the device token with its push service by itself. */
+    setAutoServerRegistration(enabled: boolean): Promise<void>;
+    /** Android: receive pushes sent to an FCM topic. */
+    subscribeToTopic(topic: string): Promise<void>;
+    unsubscribeFromTopic(topic: string): Promise<void>;
+    /**
+     * Runs a task defined with `expo-task-manager` when a notification arrives in the background.
+     * The task itself is defined at the top level of `main.ts`, since it runs without the app.
+     */
+    registerTask(name: string): Promise<void>;
+    unregisterTask(name: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Notifications, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export {};