@aws-amplify/notifications 2.0.1-console-preview.5a31ca1.0 → 2.0.1-console-preview.8d88eef.0

package/lib-esm/pushNotifications/providers/pinpoint/apis/initializePushNotifications.native.js

@@ -0,0 +1,155 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { __awaiter, __generator } from "tslib";
+import { ConsoleLogger } from '@aws-amplify/core';
+import { PushNotificationAction } from '@aws-amplify/core/internals/utils';
+import { updateEndpoint } from '@aws-amplify/core/internals/providers/pinpoint';
+import { loadAmplifyPushNotification } from '@aws-amplify/react-native';
+import { addEventListener, notifyEventListeners, notifyEventListenersAndAwaitHandlers, } from '../../../../eventListeners';
+import { createMessageEventRecorder, getChannelType, getPushNotificationUserAgentString, getToken, initialize, isInitialized, resolveConfig, resolveCredentials, setToken, } from '../utils';
+var _a = loadAmplifyPushNotification(), addMessageEventListener = _a.addMessageEventListener, addTokenEventListener = _a.addTokenEventListener, completeNotification = _a.completeNotification, getConstants = _a.getConstants, registerHeadlessTask = _a.registerHeadlessTask;
+var logger = new ConsoleLogger('Notifications.PushNotification');
+var BACKGROUND_TASK_TIMEOUT = 25; // seconds
+export var initializePushNotifications = function () {
+    if (isInitialized()) {
+        logger.info('Push notifications have already been enabled');
+        return;
+    }
+    addNativeListeners();
+    addAnalyticsListeners();
+    initialize();
+};
+var addAnalyticsListeners = function () {
+    var launchNotificationOpenedListenerRemover;
+    // wire up default Pinpoint message event handling
+    addEventListener('backgroundMessageReceived', createMessageEventRecorder('backgroundMessageReceived'));
+    addEventListener('foregroundMessageReceived', createMessageEventRecorder('foregroundMessageReceived'));
+    launchNotificationOpenedListenerRemover = addEventListener('launchNotificationsOpened', createMessageEventRecorder('notificationOpened', 
+    // once we are done with it we can remove the listener
+    launchNotificationOpenedListenerRemover === null || 
+    // once we are done with it we can remove the listener
+    launchNotificationOpenedListenerRemover === void 0 ? void 0 : 
+    // once we are done with it we can remove the listener
+    launchNotificationOpenedListenerRemover.remove));
+    addEventListener('notificationOpened', createMessageEventRecorder('notificationOpened', 
+    // if we are in this state, we no longer need the listener as the app was launched via some other means
+    launchNotificationOpenedListenerRemover === null || 
+    // if we are in this state, we no longer need the listener as the app was launched via some other means
+    launchNotificationOpenedListenerRemover === void 0 ? void 0 : 
+    // if we are in this state, we no longer need the listener as the app was launched via some other means
+    launchNotificationOpenedListenerRemover.remove));
+};
+var addNativeListeners = function () {
+    var _a = getConstants(), NativeEvent = _a.NativeEvent, NativeHeadlessTaskKey = _a.NativeHeadlessTaskKey;
+    var BACKGROUND_MESSAGE_RECEIVED = NativeEvent.BACKGROUND_MESSAGE_RECEIVED, FOREGROUND_MESSAGE_RECEIVED = NativeEvent.FOREGROUND_MESSAGE_RECEIVED, LAUNCH_NOTIFICATION_OPENED = NativeEvent.LAUNCH_NOTIFICATION_OPENED, NOTIFICATION_OPENED = NativeEvent.NOTIFICATION_OPENED, TOKEN_RECEIVED = NativeEvent.TOKEN_RECEIVED;
+    // on platforms that can handle headless tasks, register one to broadcast background message received to
+    // library listeners
+    if (NativeHeadlessTaskKey) {
+        registerHeadlessTask(function (message) { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: 
+                    // keep headless task running until handlers have completed their work
+                    return [4 /*yield*/, notifyEventListenersAndAwaitHandlers('backgroundMessageReceived', message)];
+                    case 1:
+                        // keep headless task running until handlers have completed their work
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    }
+    else if (BACKGROUND_MESSAGE_RECEIVED) {
+        // on platforms that can't handle headless tasks, listen for native background message received event and
+        // broadcast to library listeners
+        addMessageEventListener(BACKGROUND_MESSAGE_RECEIVED, function (message, completionHandlerId) { return __awaiter(void 0, void 0, void 0, function () {
+            var err_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, 3, 4]);
+                        return [4 /*yield*/, Promise.race([
+                                notifyEventListenersAndAwaitHandlers('backgroundMessageReceived', message),
+                                // background tasks will get suspended and all future tasks be deprioritized by the OS if they run for
+                                // more than 30 seconds so we reject with a error in a shorter amount of time to prevent this from
+                                // happening
+                                new Promise(function (_, reject) {
+                                    setTimeout(function () {
+                                        return reject("onNotificationReceivedInBackground handlers should complete their work within " + BACKGROUND_TASK_TIMEOUT + " seconds, but they did not.");
+                                    }, BACKGROUND_TASK_TIMEOUT * 1000);
+                                }),
+                            ])];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 2:
+                        err_1 = _a.sent();
+                        logger.error(err_1);
+                        return [3 /*break*/, 4];
+                    case 3:
+                        // notify native module that handlers have completed their work (or timed out)
+                        completeNotification(completionHandlerId);
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); });
+    }
+    addMessageEventListener(
+    // listen for native foreground message received event and broadcast to library listeners
+    FOREGROUND_MESSAGE_RECEIVED, function (message) {
+        notifyEventListeners('foregroundMessageReceived', message);
+    });
+    var launchNotificationOpenedListener = LAUNCH_NOTIFICATION_OPENED
+        ? addMessageEventListener(
+        // listen for native notification opened app (user tapped on notification, opening the app from quit -
+        // not background - state) event. This is broadcasted to an internal listener only as it is not intended
+        // for use otherwise as it produces inconsistent results when used within React Native app context
+        LAUNCH_NOTIFICATION_OPENED, function (message) {
+            notifyEventListeners('launchNotificationsOpened', message);
+            // once we are done with it we can remove the listener
+            launchNotificationOpenedListener === null || launchNotificationOpenedListener === void 0 ? void 0 : launchNotificationOpenedListener.remove();
+        })
+        : null;
+    addMessageEventListener(
+    // listen for native notification opened (user tapped on notification, opening the app from background -
+    // not quit - state) event and broadcast to library listeners
+    NOTIFICATION_OPENED, function (message) {
+        notifyEventListeners('notificationOpened', message);
+        // if we are in this state, we no longer need the listener as the app was launched via some other means
+        launchNotificationOpenedListener === null || launchNotificationOpenedListener === void 0 ? void 0 : launchNotificationOpenedListener.remove();
+    });
+    addTokenEventListener(
+    // listen for native new token event, automatically re-register device with provider using new token and
+    // broadcast to library listeners
+    TOKEN_RECEIVED, function (token) {
+        // avoid a race condition where two endpoints are created with the same token on a fresh install
+        if (getToken() === token) {
+            return;
+        }
+        setToken(token);
+        registerDevice();
+        notifyEventListeners('tokenReceived', token);
+    });
+};
+var registerDevice = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, credentials, identityId, _b, appId, region;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4 /*yield*/, resolveCredentials()];
+            case 1:
+                _a = _c.sent(), credentials = _a.credentials, identityId = _a.identityId;
+                _b = resolveConfig(), appId = _b.appId, region = _b.region;
+                return [2 /*return*/, updateEndpoint({
+                        address: getToken(),
+                        appId: appId,
+                        category: 'PushNotification',
+                        credentials: credentials,
+                        region: region,
+                        channelType: getChannelType(),
+                        identityId: identityId,
+                        userAgentValue: getPushNotificationUserAgentString(PushNotificationAction.InitializePushNotifications),
+                    })];
+        }
+    });
+}); };

package/lib-esm/pushNotifications/providers/pinpoint/apis/onNotificationOpened.d.ts

@@ -0,0 +1,27 @@
+import { OnNotificationOpened } from '../types';
+/**
+ * Registers a listener that will be triggered when a notification is opened by user.
+ *
+ * @param {OnNotificationOpenedInput} input - A callback handler to be invoked with the opened
+ * {@link PushNotificationMessage}.
+ * @returns {OnNotificationOpenedOutput} - An object with a remove function to remove the listener.
+ * @example
+ * ```ts
+ * // Register a listener
+ * onNotificationOpened(message => {
+ *   doSomething(message);
+ * });
+ * ```
+ * @example
+ * ```ts
+ * // Register multiple listeners
+ * onNotificationOpened(message => {
+ *   doSomething(message);
+ * });
+ *
+ * onNotificationOpened(message => {
+ *   doSomethingElse(message);
+ * });
+ * ```
+ */
+export declare const onNotificationOpened: OnNotificationOpened;

package/lib-esm/pushNotifications/providers/pinpoint/apis/onNotificationOpened.js

@@ -0,0 +1,31 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { PlatformNotSupportedError } from '@aws-amplify/core/internals/utils';
+/**
+ * Registers a listener that will be triggered when a notification is opened by user.
+ *
+ * @param {OnNotificationOpenedInput} input - A callback handler to be invoked with the opened
+ * {@link PushNotificationMessage}.
+ * @returns {OnNotificationOpenedOutput} - An object with a remove function to remove the listener.
+ * @example
+ * ```ts
+ * // Register a listener
+ * onNotificationOpened(message => {
+ *   doSomething(message);
+ * });
+ * ```
+ * @example
+ * ```ts
+ * // Register multiple listeners
+ * onNotificationOpened(message => {
+ *   doSomething(message);
+ * });
+ *
+ * onNotificationOpened(message => {
+ *   doSomethingElse(message);
+ * });
+ * ```
+ */
+export var onNotificationOpened = function () {
+    throw new PlatformNotSupportedError();
+};

package/lib-esm/pushNotifications/providers/pinpoint/apis/onNotificationOpened.native.d.ts

@@ -0,0 +1,2 @@
+import { OnNotificationOpened } from '../types';
+export declare const onNotificationOpened: OnNotificationOpened;

package/lib-esm/pushNotifications/providers/pinpoint/apis/onNotificationOpened.native.js

@@ -0,0 +1,6 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { addEventListener } from '../../../../eventListeners';
+export var onNotificationOpened = function (input) {
+    return addEventListener('notificationOpened', input);
+};

package/lib-esm/pushNotifications/providers/pinpoint/apis/onNotificationReceivedInBackground.d.ts

@@ -0,0 +1,43 @@
+import { OnNotificationReceivedInBackground } from '../types';
+/**
+ * Registers a listener that will be triggered when a notification is received while app is in a background state.
+ *
+ * @throws platform: {@link PlatformNotSupportedError} - Thrown if called against an unsupported platform. Currently,
+ * only React Native is supported by this API.
+ * @param {OnNotificationReceivedInBackgroundInput} input - A callback handler to be invoked with the received
+ * {@link PushNotificationMessage}.
+ * @returns {OnNotificationReceivedInBackgroundOutput} - An object with a remove function to remove the listener.
+ * @remarks Notifications received while app is in a quit state will start the app (as a headless JS instance running
+ * on a background service on Android) in the background. Handlers registered via this function should return promises
+ * if it needs to be asynchronous (e.g. to perform some network requests). The app should run in the background as long
+ * as there are handlers still running (however, if they run for more than 30 seconds on iOS, subsequent tasks could
+ * get deprioritized!). If it is necessary for a handler to execute while the app is in quit state, it should be
+ * registered in the application entry point (e.g. index.js) since the application will not fully mount in that case.
+ * @example
+ * ```ts
+ * // Register a listener
+ * onNotificationReceivedInBackground(message => {
+ *   doSomething(message);
+ * });
+ * ```
+ * @example
+ * ```ts
+ * // Register multiple listeners
+ * onNotificationReceivedInBackground(message => {
+ *   doSomething(message);
+ * });
+ *
+ * onNotificationReceivedInBackground(message => {
+ *   doSomethingElse(message);
+ * });
+ * ```
+ * @example
+ * ```ts
+ * // Register async listener
+ * onNotificationReceivedInBackground(async message => {
+ *   await doSomething(message);
+ *   console.log(`did something with ${message}`);
+ * });
+ * ```
+ */
+export declare const onNotificationReceivedInBackground: OnNotificationReceivedInBackground;

package/lib-esm/pushNotifications/providers/pinpoint/apis/onNotificationReceivedInBackground.js

@@ -0,0 +1,47 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { PlatformNotSupportedError } from '@aws-amplify/core/internals/utils';
+/**
+ * Registers a listener that will be triggered when a notification is received while app is in a background state.
+ *
+ * @throws platform: {@link PlatformNotSupportedError} - Thrown if called against an unsupported platform. Currently,
+ * only React Native is supported by this API.
+ * @param {OnNotificationReceivedInBackgroundInput} input - A callback handler to be invoked with the received
+ * {@link PushNotificationMessage}.
+ * @returns {OnNotificationReceivedInBackgroundOutput} - An object with a remove function to remove the listener.
+ * @remarks Notifications received while app is in a quit state will start the app (as a headless JS instance running
+ * on a background service on Android) in the background. Handlers registered via this function should return promises
+ * if it needs to be asynchronous (e.g. to perform some network requests). The app should run in the background as long
+ * as there are handlers still running (however, if they run for more than 30 seconds on iOS, subsequent tasks could
+ * get deprioritized!). If it is necessary for a handler to execute while the app is in quit state, it should be
+ * registered in the application entry point (e.g. index.js) since the application will not fully mount in that case.
+ * @example
+ * ```ts
+ * // Register a listener
+ * onNotificationReceivedInBackground(message => {
+ *   doSomething(message);
+ * });
+ * ```
+ * @example
+ * ```ts
+ * // Register multiple listeners
+ * onNotificationReceivedInBackground(message => {
+ *   doSomething(message);
+ * });
+ *
+ * onNotificationReceivedInBackground(message => {
+ *   doSomethingElse(message);
+ * });
+ * ```
+ * @example
+ * ```ts
+ * // Register async listener
+ * onNotificationReceivedInBackground(async message => {
+ *   await doSomething(message);
+ *   console.log(`did something with ${message}`);
+ * });
+ * ```
+ */
+export var onNotificationReceivedInBackground = function () {
+    throw new PlatformNotSupportedError();
+};

package/lib-esm/pushNotifications/providers/pinpoint/apis/onNotificationReceivedInBackground.native.d.ts

@@ -0,0 +1,2 @@
+import { OnNotificationReceivedInBackground } from '../types';
+export declare const onNotificationReceivedInBackground: OnNotificationReceivedInBackground;

package/lib-esm/pushNotifications/providers/pinpoint/apis/onNotificationReceivedInBackground.native.js

@@ -0,0 +1,4 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { addEventListener } from '../../../../eventListeners';
+export var onNotificationReceivedInBackground = function (input) { return addEventListener('backgroundMessageReceived', input); };

package/lib-esm/pushNotifications/providers/pinpoint/apis/onNotificationReceivedInForeground.d.ts

@@ -0,0 +1,27 @@
+import { OnNotificationReceivedInForeground } from '../types';
+/**
+ * Registers a listener that will be triggered when a notification is received while app is in a foreground state.
+ *
+ * @param {OnNotificationReceivedInForegroundInput} input - A callback handler to be invoked with the received
+ * {@link PushNotificationMessage}.
+ * @returns {OnNotificationReceivedInForegroundOutput} - An object with a remove function to remove the listener.
+ * @example
+ * ```ts
+ * // Register a listener
+ * onNotificationReceivedInForeground(message => {
+ *   doSomething(message);
+ * });
+ * ```
+ * @example
+ * ```ts
+ * // Register multiple listeners
+ * onNotificationReceivedInForeground(message => {
+ *   doSomething(message);
+ * });
+ *
+ * onNotificationReceivedInForeground(message => {
+ *   doSomethingElse(message);
+ * });
+ * ```
+ */
+export declare const onNotificationReceivedInForeground: OnNotificationReceivedInForeground;

package/lib-esm/pushNotifications/providers/pinpoint/apis/onNotificationReceivedInForeground.js

@@ -0,0 +1,31 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { PlatformNotSupportedError } from '@aws-amplify/core/internals/utils';
+/**
+ * Registers a listener that will be triggered when a notification is received while app is in a foreground state.
+ *
+ * @param {OnNotificationReceivedInForegroundInput} input - A callback handler to be invoked with the received
+ * {@link PushNotificationMessage}.
+ * @returns {OnNotificationReceivedInForegroundOutput} - An object with a remove function to remove the listener.
+ * @example
+ * ```ts
+ * // Register a listener
+ * onNotificationReceivedInForeground(message => {
+ *   doSomething(message);
+ * });
+ * ```
+ * @example
+ * ```ts
+ * // Register multiple listeners
+ * onNotificationReceivedInForeground(message => {
+ *   doSomething(message);
+ * });
+ *
+ * onNotificationReceivedInForeground(message => {
+ *   doSomethingElse(message);
+ * });
+ * ```
+ */
+export var onNotificationReceivedInForeground = function () {
+    throw new PlatformNotSupportedError();
+};

package/lib-esm/pushNotifications/providers/pinpoint/apis/onNotificationReceivedInForeground.native.d.ts

@@ -0,0 +1,2 @@
+import { OnNotificationReceivedInForeground } from '../types';
+export declare const onNotificationReceivedInForeground: OnNotificationReceivedInForeground;

package/lib-esm/pushNotifications/providers/pinpoint/apis/onNotificationReceivedInForeground.native.js

@@ -0,0 +1,4 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { addEventListener } from '../../../../eventListeners';
+export var onNotificationReceivedInForeground = function (input) { return addEventListener('foregroundMessageReceived', input); };

package/lib-esm/pushNotifications/providers/pinpoint/apis/onTokenReceived.d.ts

@@ -0,0 +1,28 @@
+import { OnTokenReceived } from '../types';
+/**
+ * Registers a listener that will be triggered when a token is received. A token will be received:
+ *   1. On every app launch, including the first install
+ *   2. When a token changes (this may happen if the service invalidates the token for any reason)
+ *
+ * @param {OnTokenReceivedInput} input - A callback handler to be invoked with the token.
+ * @returns {OnTokenReceivedOutput} - An object with a remove function to remove the listener.
+ * @example
+ * ```ts
+ * // Register a listener
+ * onTokenReceived(message => {
+ *   doSomething(message);
+ * });
+ * ```
+ * @example
+ * ```ts
+ * // Register multiple listeners
+ * onTokenReceived(message => {
+ *   doSomething(message);
+ * });
+ *
+ * onTokenReceived(message => {
+ *   doSomethingElse(message);
+ * });
+ * ```
+ */
+export declare const onTokenReceived: OnTokenReceived;

package/lib-esm/pushNotifications/providers/pinpoint/apis/onTokenReceived.js

@@ -0,0 +1,32 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { PlatformNotSupportedError } from '@aws-amplify/core/internals/utils';
+/**
+ * Registers a listener that will be triggered when a token is received. A token will be received:
+ *   1. On every app launch, including the first install
+ *   2. When a token changes (this may happen if the service invalidates the token for any reason)
+ *
+ * @param {OnTokenReceivedInput} input - A callback handler to be invoked with the token.
+ * @returns {OnTokenReceivedOutput} - An object with a remove function to remove the listener.
+ * @example
+ * ```ts
+ * // Register a listener
+ * onTokenReceived(message => {
+ *   doSomething(message);
+ * });
+ * ```
+ * @example
+ * ```ts
+ * // Register multiple listeners
+ * onTokenReceived(message => {
+ *   doSomething(message);
+ * });
+ *
+ * onTokenReceived(message => {
+ *   doSomethingElse(message);
+ * });
+ * ```
+ */
+export var onTokenReceived = function () {
+    throw new PlatformNotSupportedError();
+};

package/lib-esm/pushNotifications/providers/pinpoint/apis/onTokenReceived.native.d.ts

@@ -0,0 +1,2 @@
+import { OnTokenReceived } from '../types';
+export declare const onTokenReceived: OnTokenReceived;

package/lib-esm/pushNotifications/providers/pinpoint/apis/onTokenReceived.native.js

@@ -0,0 +1,6 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { addEventListener } from '../../../../eventListeners';
+export var onTokenReceived = function (input) {
+    return addEventListener('tokenReceived', input);
+};

package/lib-esm/pushNotifications/providers/pinpoint/apis/requestPermissions.d.ts

@@ -0,0 +1,32 @@
+import { RequestPermissions } from '../types';
+/**
+ * Requests notification permissions from your user. By default, Amplify requests all supported permissions but you can
+ * choose not to request specific permissions. The resulting promise will resolve to true if requested permissions are
+ * granted (or have previously been granted) or false otherwise. Not all specific permissions are supported by platforms
+ * your React Native app can run on but will be safely ignored even on those platforms. Currently supported permissions:
+ *
+ *   * `alert`: When set to true, requests the ability to display notifications to the user.
+ *
+ *   * `sound`: When set to true, requests the ability to play a sound in response to notifications.
+ *
+ *   * `badge`: When set to true, requests the ability to update the app's badge.
+ *
+ * @throws platform: {@link PlatformNotSupportedError} - Thrown if called against an unsupported platform. Currently,
+ * only React Native is supported by this API.
+ * @returns A promise that resolves to true if requested permissions are granted or have already previously been
+ * granted or false otherwise.
+ * @example
+ * ```ts
+ * // Request all permissions by default
+ * const arePermissionsGranted = await requestPermissions();
+ *
+ * @example
+ * ```ts
+ * // Prevent requesting specific permissions
+ * const arePermissionsGranted = await requestPermissions({
+ *   sound: false,
+ *   badge: false
+ * });
+ * ```
+ */
+export declare const requestPermissions: RequestPermissions;

package/lib-esm/pushNotifications/providers/pinpoint/apis/requestPermissions.js

@@ -0,0 +1,36 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { PlatformNotSupportedError } from '@aws-amplify/core/internals/utils';
+/**
+ * Requests notification permissions from your user. By default, Amplify requests all supported permissions but you can
+ * choose not to request specific permissions. The resulting promise will resolve to true if requested permissions are
+ * granted (or have previously been granted) or false otherwise. Not all specific permissions are supported by platforms
+ * your React Native app can run on but will be safely ignored even on those platforms. Currently supported permissions:
+ *
+ *   * `alert`: When set to true, requests the ability to display notifications to the user.
+ *
+ *   * `sound`: When set to true, requests the ability to play a sound in response to notifications.
+ *
+ *   * `badge`: When set to true, requests the ability to update the app's badge.
+ *
+ * @throws platform: {@link PlatformNotSupportedError} - Thrown if called against an unsupported platform. Currently,
+ * only React Native is supported by this API.
+ * @returns A promise that resolves to true if requested permissions are granted or have already previously been
+ * granted or false otherwise.
+ * @example
+ * ```ts
+ * // Request all permissions by default
+ * const arePermissionsGranted = await requestPermissions();
+ *
+ * @example
+ * ```ts
+ * // Prevent requesting specific permissions
+ * const arePermissionsGranted = await requestPermissions({
+ *   sound: false,
+ *   badge: false
+ * });
+ * ```
+ */
+export var requestPermissions = function () {
+    throw new PlatformNotSupportedError();
+};

package/lib-esm/pushNotifications/providers/pinpoint/apis/requestPermissions.native.d.ts

@@ -0,0 +1,2 @@
+import { RequestPermissions } from '../types';
+export declare const requestPermissions: RequestPermissions;

package/lib-esm/pushNotifications/providers/pinpoint/apis/requestPermissions.native.js

@@ -0,0 +1,7 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { loadAmplifyPushNotification } from '@aws-amplify/react-native';
+var requestPermissionsNative = loadAmplifyPushNotification().requestPermissions;
+export var requestPermissions = function (input) {
+    return requestPermissionsNative(input);
+};

package/lib-esm/pushNotifications/providers/pinpoint/apis/setBadgeCount.d.ts

@@ -0,0 +1,14 @@
+import { SetBadgeCount } from '../types';
+/**
+ * Sets the current badge count (the number on the top right corner of your app's icon). Setting the badge count
+ * to 0 (zero) will remove the badge from your app's icon. This function is safe to call (but will be ignored) even
+ * when your React Native app is running on platforms where badges are not supported.
+ *
+ * @throws platform: {@link PlatformNotSupportedError} - Thrown if called against an unsupported platform. Currently,
+ * only React Native is supported by this API.
+ * @example
+ * ```ts
+ * setBadgeCount(42);
+ * ```
+ */
+export declare const setBadgeCount: SetBadgeCount;

package/lib-esm/pushNotifications/providers/pinpoint/apis/setBadgeCount.js

@@ -0,0 +1,18 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { PlatformNotSupportedError } from '@aws-amplify/core/internals/utils';
+/**
+ * Sets the current badge count (the number on the top right corner of your app's icon). Setting the badge count
+ * to 0 (zero) will remove the badge from your app's icon. This function is safe to call (but will be ignored) even
+ * when your React Native app is running on platforms where badges are not supported.
+ *
+ * @throws platform: {@link PlatformNotSupportedError} - Thrown if called against an unsupported platform. Currently,
+ * only React Native is supported by this API.
+ * @example
+ * ```ts
+ * setBadgeCount(42);
+ * ```
+ */
+export var setBadgeCount = function () {
+    throw new PlatformNotSupportedError();
+};

package/lib-esm/pushNotifications/providers/pinpoint/apis/setBadgeCount.native.d.ts

@@ -0,0 +1,2 @@
+import { SetBadgeCount } from '../types';
+export declare const setBadgeCount: SetBadgeCount;

package/lib-esm/pushNotifications/providers/pinpoint/apis/setBadgeCount.native.js

@@ -0,0 +1,5 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { loadAmplifyPushNotification } from '@aws-amplify/react-native';
+var setBadgeCountNative = loadAmplifyPushNotification().setBadgeCount;
+export var setBadgeCount = function (input) { return setBadgeCountNative(input); };

package/lib-esm/pushNotifications/providers/pinpoint/index.d.ts

@@ -1 +1,3 @@
-export { identifyUser } from './apis';
+export { getBadgeCount, getLaunchNotification, getPermissionStatus, identifyUser, initializePushNotifications, onNotificationOpened, onNotificationReceivedInBackground, onNotificationReceivedInForeground, onTokenReceived, requestPermissions, setBadgeCount, } from './apis';
+export { IdentifyUserInput, OnNotificationOpenedInput, OnNotificationReceivedInBackgroundInput, OnNotificationReceivedInForegroundInput, OnTokenReceivedInput, RequestPermissionsInput, SetBadgeCountInput, } from './types/inputs';
+export { GetLaunchNotificationOutput, GetPermissionStatusOutput, OnNotificationOpenedOutput, OnNotificationReceivedInBackgroundOutput, OnNotificationReceivedInForegroundOutput, OnTokenReceivedOutput, } from './types/outputs';

package/lib-esm/pushNotifications/providers/pinpoint/index.js

@@ -1,4 +1,3 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-export { identifyUser } from './apis';
-//# sourceMappingURL=index.js.map
+export { getBadgeCount, getLaunchNotification, getPermissionStatus, identifyUser, initializePushNotifications, onNotificationOpened, onNotificationReceivedInBackground, onNotificationReceivedInForeground, onTokenReceived, requestPermissions, setBadgeCount, } from './apis';

package/lib-esm/pushNotifications/providers/pinpoint/types/analytics.d.ts

@@ -0,0 +1,6 @@
+export declare type PinpointMessageEvent = 'opened_notification' | 'received_background' | 'received_foreground';
+export declare type PinpointMessageEventSource = '_campaign' | '_journey';
+export declare type AnalyticsEventAttributes = {
+    source: PinpointMessageEventSource;
+    attributes: Record<string, string>;
+};

package/lib-esm/{common/eventListeners/types.js → pushNotifications/providers/pinpoint/types/analytics.js}

@@ -1,3 +1,2 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-//# sourceMappingURL=types.js.map