@ng-native/expo 0.0.1 → 0.1.1

package/dist/notifications.js

@@ -0,0 +1,296 @@
+/**
+ * `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 { DestroyRef, InjectionToken, Service, inject, signal } from '@angular/core';
+import { expoModule } from "./native.js";
+import { Permission } from "./permissions.js";
+import * as i0 from "@angular/core";
+/**
+ * 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 const TriggerType = {
+    CALENDAR: 'calendar',
+    DAILY: 'daily',
+    WEEKLY: 'weekly',
+    MONTHLY: 'monthly',
+    YEARLY: 'yearly',
+    DATE: 'date',
+    TIME_INTERVAL: 'timeInterval',
+};
+/** The permission answer without the module: nothing granted, and nothing to ask. */
+const UNAVAILABLE = { status: 'denied', granted: false, canAskAgain: false };
+export class Notifications {
+    /** Overridden in a test to deliver a notification nobody sent. */
+    static SOURCE = new InjectionToken('angular-native.notificationsSource', {
+        factory: () => expoModule('expo-notifications', () => require('expo-notifications')),
+    });
+    native = inject(Notifications.SOURCE);
+    received = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "received" }] : /* istanbul ignore next */ []));
+    responded = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "responded" }] : /* istanbul ignore next */ []));
+    rolled = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "rolled" }] : /* istanbul ignore next */ []));
+    drops = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "drops" }] : /* istanbul ignore next */ []));
+    handled = new Set();
+    /**
+     * 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}.
+     */
+    permission;
+    constructor() {
+        const native = this.native;
+        this.permission = Permission.of(() => native?.getPermissionsAsync() ?? Promise.resolve(UNAVAILABLE), () => native?.requestPermissionsAsync() ?? Promise.resolve(UNAVAILABLE));
+        if (!native)
+            return;
+        const subscriptions = [
+            native.addNotificationReceivedListener((notification) => this.received.set(notification)),
+            native.addNotificationResponseReceivedListener((response) => this.responded.set(response)),
+            // Android drops notifications when too many arrive at once while the app is not running;
+            // this is the only word that any went missing.
+            native.addNotificationsDroppedListener(() => this.drops.update((count) => count + 1)),
+            // A device push token can be rolled by the platform while the app is running; the old one
+            // then fails silently rather than delivering anything. This is the only way to find out.
+            native.addPushTokenListener((token) => this.rolled.set(token)),
+        ];
+        inject(DestroyRef).onDestroy(() => subscriptions.forEach((one) => one.remove()));
+        // The response that launched the app happened before anything was listening, so it has to be
+        // asked for rather than waited for. Without this a cold start from a notification does
+        // nothing, which is the single most common way this is got wrong. A platform that cannot say
+        // is the same as a launch without a notification.
+        void native
+            .getLastNotificationResponseAsync()
+            .then((response) => {
+            if (response && this.responded() === null)
+                this.responded.set(response);
+        })
+            .catch(() => { });
+    }
+    /** The most recent notification that arrived while the app was in front. */
+    latest = this.received.asReadonly();
+    /**
+     * 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.
+     */
+    response = this.responded.asReadonly();
+    /**
+     * 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() {
+        const response = this.responded();
+        if (!response)
+            return null;
+        const id = response.notification.request.identifier + response.actionIdentifier;
+        if (this.handled.has(id))
+            return null;
+        this.handled.add(id);
+        return response;
+    }
+    /** Forgets the tap, here and in the module, so the next launch does not see it again. */
+    async clearResponse() {
+        this.responded.set(null);
+        await this.native?.clearLastNotificationResponseAsync();
+    }
+    /** How many times Android has reported notifications dropped. Zero on iOS. */
+    dropped = this.drops.asReadonly();
+    /** Asks with iOS's finer options. The answer also updates {@link permission}. */
+    async requestPermission(...options) {
+        if (!this.native)
+            return false;
+        await this.native.requestPermissionsAsync(...options);
+        return this.permission.check();
+    }
+    /** Schedules a local notification, or shows it now with a null trigger. Null without the module. */
+    async schedule(...request) {
+        return (await this.native?.scheduleNotificationAsync(...request)) ?? null;
+    }
+    async cancel(identifier) {
+        await this.native?.cancelScheduledNotificationAsync(identifier);
+    }
+    async cancelAll() {
+        await this.native?.cancelAllScheduledNotificationsAsync();
+    }
+    /** Every local notification still waiting for its trigger. */
+    async scheduled() {
+        return (await this.native?.getAllScheduledNotificationsAsync()) ?? [];
+    }
+    /** When a trigger would next fire, in milliseconds since the epoch; null if it never will. */
+    async nextTriggerDate(...trigger) {
+        return (await this.native?.getNextTriggerDateAsync(...trigger)) ?? null;
+    }
+    /** The notifications in the notification centre that are the app's. */
+    async presented() {
+        return (await this.native?.getPresentedNotificationsAsync()) ?? [];
+    }
+    async dismiss(identifier) {
+        await this.native?.dismissNotificationAsync(identifier);
+    }
+    /** Clears every notification the app has on screen. A failure is ignored. */
+    dismissAll() {
+        void this.native?.dismissAllNotificationsAsync().catch(() => { });
+    }
+    async badge() {
+        return (await this.native?.getBadgeCountAsync()) ?? 0;
+    }
+    /**
+     * iOS shows this on the icon; Android shows it where the launcher supports it. A failure is
+     * ignored.
+     */
+    setBadge(count) {
+        void this.native?.setBadgeCountAsync(count).catch(() => { });
+    }
+    /** Android's notification channels. Empty on iOS, which has none. */
+    async channels() {
+        return (await this.native?.getNotificationChannelsAsync()) ?? [];
+    }
+    async channel(identifier) {
+        return (await this.native?.getNotificationChannelAsync(identifier)) ?? null;
+    }
+    /**
+     * Creates or updates an Android channel; a notification on Android 8 and later needs one to
+     * show at all. Null on iOS.
+     */
+    async setChannel(...channel) {
+        return (await this.native?.setNotificationChannelAsync(...channel)) ?? null;
+    }
+    async deleteChannel(identifier) {
+        await this.native?.deleteNotificationChannelAsync(identifier);
+    }
+    async channelGroups() {
+        return (await this.native?.getNotificationChannelGroupsAsync()) ?? [];
+    }
+    async channelGroup(identifier) {
+        return (await this.native?.getNotificationChannelGroupAsync(identifier)) ?? null;
+    }
+    async setChannelGroup(...group) {
+        return (await this.native?.setNotificationChannelGroupAsync(...group)) ?? null;
+    }
+    async deleteChannelGroup(identifier) {
+        await this.native?.deleteNotificationChannelGroupAsync(identifier);
+    }
+    /** The categories set: each a set of action buttons a notification opts into. */
+    async categories() {
+        return (await this.native?.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.
+     */
+    async setCategory(...category) {
+        return (await this.native?.setNotificationCategoryAsync(...category)) ?? null;
+    }
+    async deleteCategory(identifier) {
+        return (await this.native?.deleteNotificationCategoryAsync(identifier)) ?? false;
+    }
+    /**
+     * 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) {
+        this.native?.setNotificationHandler(...handler);
+    }
+    /**
+     * 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.
+     */
+    async getExpoPushToken(projectId) {
+        if (!this.native || !(await this.permission.ensure()))
+            return null;
+        const token = await this.native.getExpoPushTokenAsync(projectId ? { projectId } : undefined);
+        return token.data;
+    }
+    /**
+     * 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}.
+     */
+    async getDevicePushToken() {
+        if (!this.native || !(await this.permission.ensure()))
+            return null;
+        return this.native.getDevicePushTokenAsync();
+    }
+    /**
+     * 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.
+     */
+    devicePushToken = this.rolled.asReadonly();
+    /** Stops the device receiving pushes until a token is asked for again. */
+    async unregister() {
+        await this.native?.unregisterForNotificationsAsync();
+    }
+    /** Whether Expo re-registers the device token with its push service by itself. */
+    async setAutoServerRegistration(enabled) {
+        await this.native?.setAutoServerRegistrationEnabledAsync(enabled);
+    }
+    /** Android: receive pushes sent to an FCM topic. */
+    async subscribeToTopic(topic) {
+        await this.native?.subscribeToTopicAsync(topic);
+    }
+    async unsubscribeFromTopic(topic) {
+        await this.native?.unsubscribeFromTopicAsync(topic);
+    }
+    /**
+     * 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.
+     */
+    async registerTask(name) {
+        await this.native?.registerTaskAsync(name);
+    }
+    async unregisterTask(name) {
+        await this.native?.unregisterTaskAsync(name);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Notifications, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.2.0", ngImport: i0, type: Notifications });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: Notifications, decorators: [{
+            type: Service
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=notifications.js.map

package/dist/notifications.js.map

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

package/dist/observed.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The shape nearly every device-state module has, and the one part of it that is React-only.
+ *
+ * `getNetworkStateAsync` + `addNetworkStateListener` + `useNetworkState`. `getBatteryLevelAsync` +
+ * `addBatteryLevelListener` + `useBatteryLevel`. The two functions are plain; the hook is React
+ * state around them, and a hook is the only surface some of these offer for *reading over time*.
+ *
+ * So this is that hook, as a signal: a value that starts at a stated default, is fetched once,
+ * and follows the listener from then on.
+ */
+import { type Signal } from '@angular/core';
+/** A value the platform knows now and will say more about later. */
+export interface Observed<T> {
+    current(): Promise<T>;
+    subscribe(listener: (value: T) => void): () => void;
+}
+/**
+ * A signal fed by an `Observed`, subscribed until the injector it was made in is destroyed.
+ *
+ * Called in an injection context, as `inject()` is - a field initialiser or a constructor - so
+ * that for a root service the subscription ends with the app. An app cares about the battery for
+ * as long as it is running, and not after: one that is mounted and unmounted would otherwise leave
+ * a listener behind each time.
+ *
+ * `initial` is what the value is before the platform has answered, which is always at least one
+ * turn: every one of these getters is asynchronous even when the answer is already in memory.
+ */
+export declare function observed<T>(source: Observed<T> | null, initial: T): Signal<T>;
+/**
+ * An `Observed` from the pair of functions these modules always expose.
+ *
+ * Named for what it makes rather than `from`, which is what it was: the package index re-exports
+ * everything, and a bare `from` in an app's import list says nothing about what it is from.
+ */
+export declare function observedFrom<T>(current: () => Promise<T>, subscribe: (listener: (value: T) => void) => {
+    remove(): void;
+}): Observed<T>;

package/dist/observed.js

@@ -0,0 +1,55 @@
+/**
+ * The shape nearly every device-state module has, and the one part of it that is React-only.
+ *
+ * `getNetworkStateAsync` + `addNetworkStateListener` + `useNetworkState`. `getBatteryLevelAsync` +
+ * `addBatteryLevelListener` + `useBatteryLevel`. The two functions are plain; the hook is React
+ * state around them, and a hook is the only surface some of these offer for *reading over time*.
+ *
+ * So this is that hook, as a signal: a value that starts at a stated default, is fetched once,
+ * and follows the listener from then on.
+ */
+import { DestroyRef, inject, signal } from '@angular/core';
+/**
+ * A signal fed by an `Observed`, subscribed until the injector it was made in is destroyed.
+ *
+ * Called in an injection context, as `inject()` is - a field initialiser or a constructor - so
+ * that for a root service the subscription ends with the app. An app cares about the battery for
+ * as long as it is running, and not after: one that is mounted and unmounted would otherwise leave
+ * a listener behind each time.
+ *
+ * `initial` is what the value is before the platform has answered, which is always at least one
+ * turn: every one of these getters is asynchronous even when the answer is already in memory.
+ */
+export function observed(source, initial) {
+    const value = signal(initial, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "value" }] : /* istanbul ignore next */ []));
+    if (!source)
+        return value.asReadonly();
+    // Failures are swallowed rather than surfaced: a device with no battery API is a device where
+    // the default is the honest answer, and nothing on screen should break over it. The first
+    // answer was asked for before anything was heard, so it is older than anything the listener
+    // has said by the time it arrives, and is dropped then.
+    let heard = false;
+    void source.current().then((first) => heard || value.set(first), () => { });
+    inject(DestroyRef).onDestroy(source.subscribe((next) => {
+        heard = true;
+        value.set(next);
+    }));
+    return value.asReadonly();
+}
+/**
+ * An `Observed` from the pair of functions these modules always expose.
+ *
+ * Named for what it makes rather than `from`, which is what it was: the package index re-exports
+ * everything, and a bare `from` in an app's import list says nothing about what it is from.
+ */
+export function observedFrom(current, subscribe) {
+    return {
+        current,
+        subscribe: (listener) => {
+            const subscription = subscribe(listener);
+            return () => subscription.remove();
+        },
+    };
+}
+//# sourceMappingURL=observed.js.map

package/dist/observed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observed.js","sourceRoot":"","sources":["../src/observed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAe,MAAM,eAAe,CAAC;AAQxE;;;;;;;;;;GAUG;AACH,MAAM,UAAU,QAAQ,CAAI,MAA0B,EAAE,OAAU;IAChE,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO;8EAAC,CAAC;IAC9B,IAAI,CAAC,MAAM;QAAE,OAAO,KAAK,CAAC,UAAU,EAAE,CAAC;IAEvC,8FAA8F;IAC9F,0FAA0F;IAC1F,4FAA4F;IAC5F,wDAAwD;IACxD,IAAI,KAAK,GAAG,KAAK,CAAC;IAClB,KAAK,MAAM,CAAC,OAAO,EAAE,CAAC,IAAI,CACxB,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,EACpC,GAAG,EAAE,GAAE,CAAC,CACT,CAAC;IACF,MAAM,CAAC,UAAU,CAAC,CAAC,SAAS,CAC1B,MAAM,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE;QACxB,KAAK,GAAG,IAAI,CAAC;QACb,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAClB,CAAC,CAAC,CACH,CAAC;IACF,OAAO,KAAK,CAAC,UAAU,EAAE,CAAC;AAC5B,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAC1B,OAAyB,EACzB,SAA+D;IAE/D,OAAO;QACL,OAAO;QACP,SAAS,EAAE,CAAC,QAAQ,EAAE,EAAE;YACtB,MAAM,YAAY,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;YACzC,OAAO,GAAG,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC;QACrC,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["/**\n * The shape nearly every device-state module has, and the one part of it that is React-only.\n *\n * `getNetworkStateAsync` + `addNetworkStateListener` + `useNetworkState`. `getBatteryLevelAsync` +\n * `addBatteryLevelListener` + `useBatteryLevel`. The two functions are plain; the hook is React\n * state around them, and a hook is the only surface some of these offer for *reading over time*.\n *\n * So this is that hook, as a signal: a value that starts at a stated default, is fetched once,\n * and follows the listener from then on.\n */\nimport { DestroyRef, inject, signal, type Signal } from '@angular/core';\n\n/** A value the platform knows now and will say more about later. */\nexport interface Observed<T> {\n  current(): Promise<T>;\n  subscribe(listener: (value: T) => void): () => void;\n}\n\n/**\n * A signal fed by an `Observed`, subscribed until the injector it was made in is destroyed.\n *\n * Called in an injection context, as `inject()` is - a field initialiser or a constructor - so\n * that for a root service the subscription ends with the app. An app cares about the battery for\n * as long as it is running, and not after: one that is mounted and unmounted would otherwise leave\n * a listener behind each time.\n *\n * `initial` is what the value is before the platform has answered, which is always at least one\n * turn: every one of these getters is asynchronous even when the answer is already in memory.\n */\nexport function observed<T>(source: Observed<T> | null, initial: T): Signal<T> {\n  const value = signal(initial);\n  if (!source) return value.asReadonly();\n\n  // Failures are swallowed rather than surfaced: a device with no battery API is a device where\n  // the default is the honest answer, and nothing on screen should break over it. The first\n  // answer was asked for before anything was heard, so it is older than anything the listener\n  // has said by the time it arrives, and is dropped then.\n  let heard = false;\n  void source.current().then(\n    (first) => heard || value.set(first),\n    () => {},\n  );\n  inject(DestroyRef).onDestroy(\n    source.subscribe((next) => {\n      heard = true;\n      value.set(next);\n    }),\n  );\n  return value.asReadonly();\n}\n\n/**\n * An `Observed` from the pair of functions these modules always expose.\n *\n * Named for what it makes rather than `from`, which is what it was: the package index re-exports\n * everything, and a bare `from` in an app's import list says nothing about what it is from.\n */\nexport function observedFrom<T>(\n  current: () => Promise<T>,\n  subscribe: (listener: (value: T) => void) => { remove(): void },\n): Observed<T> {\n  return {\n    current,\n    subscribe: (listener) => {\n      const subscription = subscribe(listener);\n      return () => subscription.remove();\n    },\n  };\n}\n"]}

package/dist/orientation.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `DeviceOrientation`, bound to `expo-screen-orientation`.
+ *
+ * Named for the device rather than the screen because that is what it reports: a layout asking
+ * which way *it* is laid out wants the `orientation` media feature, which needs none of this.
+ * This is what a camera preview or a video player needs - a screen locked to portrait still has a
+ * phone that is sideways.
+ */
+import { InjectionToken, type Signal } from '@angular/core';
+import { type Observed } from './observed.ts';
+import * as i0 from "@angular/core";
+export type Orientation = 'unknown' | 'portrait' | 'portrait-upside-down' | 'landscape-left' | 'landscape-right';
+/** What a screen may rotate to. `default` is portrait plus, on a phone, nothing else. */
+export type OrientationLock = 'default' | 'all' | 'portrait' | 'landscape';
+export interface OrientationSource {
+    readonly reported: Observed<Orientation> | null;
+    lock(lock: OrientationLock): Promise<void>;
+    unlock(): Promise<void>;
+}
+export declare class DeviceOrientation {
+    /** Overridden in a test to rotate a device that is not there. */
+    static readonly SOURCE: InjectionToken<OrientationSource>;
+    private readonly source;
+    readonly orientation: Signal<Orientation>;
+    readonly landscape: Signal<boolean>;
+    /**
+     * Pin the screen. Returns the function that unpins it, so a screen that wants landscape while
+     * it is up can hand it to `DestroyRef.onDestroy` and not think about it again.
+     */
+    lock(lock: OrientationLock): () => void;
+    /** Every lock not yet released, the one in force last. */
+    private readonly locks;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeviceOrientation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}

package/dist/orientation.js

@@ -0,0 +1,78 @@
+/**
+ * `DeviceOrientation`, bound to `expo-screen-orientation`.
+ *
+ * Named for the device rather than the screen because that is what it reports: a layout asking
+ * which way *it* is laid out wants the `orientation` media feature, which needs none of this.
+ * This is what a camera preview or a video player needs - a screen locked to portrait still has a
+ * phone that is sideways.
+ */
+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";
+const NOTHING = {
+    reported: null,
+    lock: () => Promise.resolve(),
+    unlock: () => Promise.resolve(),
+};
+export class DeviceOrientation {
+    /** Overridden in a test to rotate a device that is not there. */
+    static SOURCE = new InjectionToken('angular-native.orientationSource', {
+        factory: () => {
+            const expo = expoModule('expo-screen-orientation', () => require('expo-screen-orientation'));
+            if (!expo)
+                return NOTHING;
+            const ORIENTATIONS = {
+                [expo.Orientation.UNKNOWN]: 'unknown',
+                [expo.Orientation.PORTRAIT_UP]: 'portrait',
+                [expo.Orientation.PORTRAIT_DOWN]: 'portrait-upside-down',
+                [expo.Orientation.LANDSCAPE_LEFT]: 'landscape-left',
+                [expo.Orientation.LANDSCAPE_RIGHT]: 'landscape-right',
+            };
+            const LOCKS = {
+                default: expo.OrientationLock.DEFAULT,
+                all: expo.OrientationLock.ALL,
+                portrait: expo.OrientationLock.PORTRAIT,
+                landscape: expo.OrientationLock.LANDSCAPE,
+            };
+            return {
+                reported: observedFrom(async () => ORIENTATIONS[await expo.getOrientationAsync()] ?? 'unknown', (listener) => expo.addOrientationChangeListener(({ orientationInfo }) => listener(ORIENTATIONS[orientationInfo.orientation] ?? 'unknown'))),
+                lock: (lock) => expo.lockAsync(LOCKS[lock]),
+                unlock: () => expo.unlockAsync(),
+            };
+        },
+    });
+    source = inject(DeviceOrientation.SOURCE);
+    orientation = observed(this.source.reported, 'unknown');
+    landscape = computed(() => this.orientation().startsWith('landscape'), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "landscape" }] : /* istanbul ignore next */ []));
+    /**
+     * Pin the screen. Returns the function that unpins it, so a screen that wants landscape while
+     * it is up can hand it to `DestroyRef.onDestroy` and not think about it again.
+     */
+    lock(lock) {
+        // A stack, as the status bar's is: a screen pushed over one with a lock of its own releases
+        // only its own, and the lock beneath it comes back rather than the whole app unlocking.
+        const entry = { lock };
+        this.locks.push(entry);
+        void this.source.lock(lock);
+        return () => {
+            const at = this.locks.indexOf(entry);
+            if (at === -1)
+                return;
+            this.locks.splice(at, 1);
+            if (at < this.locks.length)
+                return;
+            const below = this.locks.at(-1);
+            void (below ? this.source.lock(below.lock) : this.source.unlock());
+        };
+    }
+    /** Every lock not yet released, the one in force last. */
+    locks = [];
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: DeviceOrientation, deps: [], target: i0.ɵɵFactoryTarget.Service });
+    static ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.2.0", ngImport: i0, type: DeviceOrientation });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: DeviceOrientation, decorators: [{
+            type: Service
+        }] });
+//# sourceMappingURL=orientation.js.map

package/dist/orientation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orientation.js","sourceRoot":"","sources":["../src/orientation.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `DeviceOrientation`, bound to `expo-screen-orientation`.\n *\n * Named for the device rather than the screen because that is what it reports: a layout asking\n * which way *it* is laid out wants the `orientation` media feature, which needs none of this.\n * This is what a camera preview or a video player needs - a screen locked to portrait still has a\n * phone that is sideways.\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 Orientation =\n  'unknown' | 'portrait' | 'portrait-upside-down' | 'landscape-left' | 'landscape-right';\n\n/** What a screen may rotate to. `default` is portrait plus, on a phone, nothing else. */\nexport type OrientationLock = 'default' | 'all' | 'portrait' | 'landscape';\n\nexport interface OrientationSource {\n  readonly reported: Observed<Orientation> | null;\n  lock(lock: OrientationLock): Promise<void>;\n  unlock(): Promise<void>;\n}\n\nconst NOTHING: OrientationSource = {\n  reported: null,\n  lock: () => Promise.resolve(),\n  unlock: () => Promise.resolve(),\n};\n\n@Service()\nexport class DeviceOrientation {\n  /** Overridden in a test to rotate a device that is not there. */\n  static readonly SOURCE = new InjectionToken<OrientationSource>(\n    'angular-native.orientationSource',\n    {\n      factory: () => {\n        const expo = expoModule(\n          'expo-screen-orientation',\n          () => require('expo-screen-orientation') as typeof import('expo-screen-orientation'),\n        );\n        if (!expo) return NOTHING;\n\n        const ORIENTATIONS: Record<number, Orientation> = {\n          [expo.Orientation.UNKNOWN]: 'unknown',\n          [expo.Orientation.PORTRAIT_UP]: 'portrait',\n          [expo.Orientation.PORTRAIT_DOWN]: 'portrait-upside-down',\n          [expo.Orientation.LANDSCAPE_LEFT]: 'landscape-left',\n          [expo.Orientation.LANDSCAPE_RIGHT]: 'landscape-right',\n        };\n        const LOCKS: Record<OrientationLock, import('expo-screen-orientation').OrientationLock> = {\n          default: expo.OrientationLock.DEFAULT,\n          all: expo.OrientationLock.ALL,\n          portrait: expo.OrientationLock.PORTRAIT,\n          landscape: expo.OrientationLock.LANDSCAPE,\n        };\n\n        return {\n          reported: observedFrom(\n            async () => ORIENTATIONS[await expo.getOrientationAsync()] ?? 'unknown',\n            (listener) =>\n              expo.addOrientationChangeListener(({ orientationInfo }) =>\n                listener(ORIENTATIONS[orientationInfo.orientation] ?? 'unknown'),\n              ),\n          ),\n          lock: (lock) => expo.lockAsync(LOCKS[lock]),\n          unlock: () => expo.unlockAsync(),\n        };\n      },\n    },\n  );\n\n  private readonly source = inject(DeviceOrientation.SOURCE);\n\n  readonly orientation: Signal<Orientation> = observed(this.source.reported, 'unknown');\n\n  readonly landscape: Signal<boolean> = computed(() => this.orientation().startsWith('landscape'));\n\n  /**\n   * Pin the screen. Returns the function that unpins it, so a screen that wants landscape while\n   * it is up can hand it to `DestroyRef.onDestroy` and not think about it again.\n   */\n  lock(lock: OrientationLock): () => void {\n    // A stack, as the status bar's is: a screen pushed over one with a lock of its own releases\n    // only its own, and the lock beneath it comes back rather than the whole app unlocking.\n    const entry = { lock };\n    this.locks.push(entry);\n    void this.source.lock(lock);\n    return () => {\n      const at = this.locks.indexOf(entry);\n      if (at === -1) return;\n      this.locks.splice(at, 1);\n      if (at < this.locks.length) return;\n      const below = this.locks.at(-1);\n      void (below ? this.source.lock(below.lock) : this.source.unlock());\n    };\n  }\n\n  /** Every lock not yet released, the one in force last. */\n  private readonly locks: { readonly lock: OrientationLock }[] = [];\n}\n"]}

package/dist/permissions.d.ts

@@ -0,0 +1,54 @@
+/**
+ * A permission, as signals rather than a hook.
+ *
+ * Every Expo module that needs one exposes the same shape: `getXPermissionsAsync`,
+ * `requestXPermissionsAsync`, and a `useXPermissions()` hook that is those two plus React state.
+ * So this is not a facade per module - it is one class that takes the pair, and the module stays
+ * the app's own dependency:
+ *
+ * ```ts
+ * import * as Camera from 'expo-camera';
+ * import { Permission } from '@ng-native/expo';
+ *
+ * readonly camera = Permission.of(Camera.Camera.getCameraPermissionsAsync,
+ *                                 Camera.Camera.requestCameraPermissionsAsync);
+ * ```
+ */
+import { type Signal } from '@angular/core';
+/** What every Expo permission call answers with. */
+export interface PermissionResponse {
+    readonly status: 'granted' | 'denied' | 'undetermined';
+    readonly granted: boolean;
+    /** False once the platform will no longer show a dialog: the app must send them to Settings. */
+    readonly canAskAgain: boolean;
+}
+/** The pair of functions a module exposes, which its hook is built out of. */
+export interface PermissionApi {
+    get(): Promise<PermissionResponse>;
+    request(): Promise<PermissionResponse>;
+}
+export declare class Permission {
+    private readonly api;
+    private readonly last;
+    constructor(api: PermissionApi);
+    /** `unknown` until something has asked the platform, which is not the same as `undetermined`. */
+    readonly status: Signal<PermissionResponse['status'] | 'unknown'>;
+    readonly granted: Signal<boolean>;
+    /** Refused, and the platform will not show a dialog again. Send them to Settings. */
+    readonly blocked: Signal<boolean>;
+    /** From a module's own two functions, which is how every one of them spells this. */
+    static of(get: () => Promise<PermissionResponse>, request: () => Promise<PermissionResponse>): Permission;
+    /** Ask the platform what it currently thinks, without showing anything to the user. */
+    check(): Promise<boolean>;
+    /** Show the dialog. Resolves to what the user said. */
+    request(): Promise<boolean>;
+    /**
+     * Have the permission if it can be had, asking only if asking would do something.
+     *
+     * The method most call sites want. A permission already granted needs no dialog, and one the
+     * platform has stopped asking about would return the same no while looking like the user had
+     * been consulted.
+     */
+    ensure(): Promise<boolean>;
+    private record;
+}