@aws-amplify/notifications 2.0.1-api-v6-models.8035dfc.0 → 2.0.1-api-v6-models.572a7b5.0

package/lib/pushNotifications/providers/pinpoint/apis/index.js

@@ -2,6 +2,25 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
+var getBadgeCount_1 = require("./getBadgeCount");
+exports.getBadgeCount = getBadgeCount_1.getBadgeCount;
+var getLaunchNotification_1 = require("./getLaunchNotification");
+exports.getLaunchNotification = getLaunchNotification_1.getLaunchNotification;
+var getPermissionStatus_1 = require("./getPermissionStatus");
+exports.getPermissionStatus = getPermissionStatus_1.getPermissionStatus;
 var identifyUser_1 = require("./identifyUser");
 exports.identifyUser = identifyUser_1.identifyUser;
-//# sourceMappingURL=index.js.map
+var initializePushNotifications_1 = require("./initializePushNotifications");
+exports.initializePushNotifications = initializePushNotifications_1.initializePushNotifications;
+var onNotificationOpened_1 = require("./onNotificationOpened");
+exports.onNotificationOpened = onNotificationOpened_1.onNotificationOpened;
+var onNotificationReceivedInBackground_1 = require("./onNotificationReceivedInBackground");
+exports.onNotificationReceivedInBackground = onNotificationReceivedInBackground_1.onNotificationReceivedInBackground;
+var onNotificationReceivedInForeground_1 = require("./onNotificationReceivedInForeground");
+exports.onNotificationReceivedInForeground = onNotificationReceivedInForeground_1.onNotificationReceivedInForeground;
+var onTokenReceived_1 = require("./onTokenReceived");
+exports.onTokenReceived = onTokenReceived_1.onTokenReceived;
+var requestPermissions_1 = require("./requestPermissions");
+exports.requestPermissions = requestPermissions_1.requestPermissions;
+var setBadgeCount_1 = require("./setBadgeCount");
+exports.setBadgeCount = setBadgeCount_1.setBadgeCount;

package/lib/pushNotifications/providers/pinpoint/apis/initializePushNotifications.d.ts

@@ -0,0 +1,17 @@
+import { InitializePushNotifications } from '../types';
+/**
+ * Initialize and set up the push notification category. The category must be first initialized before all other
+ * functionalities become available.
+ *
+ * @throws platform: {@link PlatformNotSupportedError} - Thrown if called against an unsupported platform. Currently,
+ * only React Native is supported by this API.
+ * @remarks
+ * It is recommended that this be called as early in your app as possible at the root of your application to allow
+ * background processing of notifications.
+ * @example
+ * ```ts
+ * Amplify.configure(config);
+ * initializePushNotifications();
+ * ```
+ */
+export declare const initializePushNotifications: InitializePushNotifications;

package/lib/pushNotifications/providers/pinpoint/apis/initializePushNotifications.js

@@ -0,0 +1,23 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@aws-amplify/core/internals/utils");
+/**
+ * Initialize and set up the push notification category. The category must be first initialized before all other
+ * functionalities become available.
+ *
+ * @throws platform: {@link PlatformNotSupportedError} - Thrown if called against an unsupported platform. Currently,
+ * only React Native is supported by this API.
+ * @remarks
+ * It is recommended that this be called as early in your app as possible at the root of your application to allow
+ * background processing of notifications.
+ * @example
+ * ```ts
+ * Amplify.configure(config);
+ * initializePushNotifications();
+ * ```
+ */
+exports.initializePushNotifications = function () {
+    throw new utils_1.PlatformNotSupportedError();
+};

package/lib/pushNotifications/providers/pinpoint/apis/initializePushNotifications.native.d.ts

@@ -0,0 +1 @@
+export declare const initializePushNotifications: () => Promise<void>;

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

@@ -0,0 +1,158 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var core_1 = require("@aws-amplify/core");
+var utils_1 = require("@aws-amplify/core/internals/utils");
+var pinpoint_1 = require("@aws-amplify/core/internals/providers/pinpoint");
+var react_native_1 = require("@aws-amplify/react-native");
+var eventListeners_1 = require("../../../../eventListeners");
+var utils_2 = require("../../../utils");
+var utils_3 = require("../utils");
+var _a = react_native_1.loadAmplifyPushNotification(), addMessageEventListener = _a.addMessageEventListener, addTokenEventListener = _a.addTokenEventListener, completeNotification = _a.completeNotification, getConstants = _a.getConstants, registerHeadlessTask = _a.registerHeadlessTask;
+var logger = new core_1.ConsoleLogger('Notifications.PushNotification');
+var BACKGROUND_TASK_TIMEOUT = 25; // seconds
+exports.initializePushNotifications = function () {
+    if (utils_2.isInitialized()) {
+        logger.info('Push notifications have already been enabled');
+        return;
+    }
+    addNativeListeners();
+    addAnalyticsListeners();
+    utils_2.initialize();
+};
+var addAnalyticsListeners = function () {
+    var launchNotificationOpenedListenerRemover;
+    // wire up default Pinpoint message event handling
+    eventListeners_1.addEventListener('backgroundMessageReceived', utils_3.createMessageEventRecorder('backgroundMessageReceived'));
+    eventListeners_1.addEventListener('foregroundMessageReceived', utils_3.createMessageEventRecorder('foregroundMessageReceived'));
+    launchNotificationOpenedListenerRemover = eventListeners_1.addEventListener('launchNotificationsOpened', utils_3.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));
+    eventListeners_1.addEventListener('notificationOpened', utils_3.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 tslib_1.__awaiter(void 0, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: 
+                    // keep headless task running until handlers have completed their work
+                    return [4 /*yield*/, eventListeners_1.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 tslib_1.__awaiter(void 0, void 0, void 0, function () {
+            var err_1;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, 3, 4]);
+                        return [4 /*yield*/, Promise.race([
+                                eventListeners_1.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) {
+        eventListeners_1.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) {
+            eventListeners_1.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) {
+        eventListeners_1.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 (utils_2.getToken() === token) {
+            return;
+        }
+        utils_2.setToken(token);
+        registerDevice();
+        eventListeners_1.notifyEventListeners('tokenReceived', token);
+    });
+};
+var registerDevice = function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var _a, credentials, identityId, _b, appId, region;
+    return tslib_1.__generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4 /*yield*/, utils_2.resolveCredentials()];
+            case 1:
+                _a = _c.sent(), credentials = _a.credentials, identityId = _a.identityId;
+                _b = utils_2.resolveConfig(), appId = _b.appId, region = _b.region;
+                return [2 /*return*/, pinpoint_1.updateEndpoint({
+                        address: utils_2.getToken(),
+                        appId: appId,
+                        category: 'PushNotification',
+                        credentials: credentials,
+                        region: region,
+                        channelType: utils_3.getChannelType(),
+                        identityId: identityId,
+                        userAgentValue: utils_3.getPushNotificationUserAgentString(utils_1.PushNotificationAction.InitializePushNotifications),
+                    })];
+        }
+    });
+}); };

package/lib/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/pushNotifications/providers/pinpoint/apis/onNotificationOpened.js

@@ -0,0 +1,33 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@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);
+ * });
+ * ```
+ */
+exports.onNotificationOpened = function () {
+    throw new utils_1.PlatformNotSupportedError();
+};

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

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

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

@@ -0,0 +1,10 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+var eventListeners_1 = require("../../../../eventListeners");
+var errorHelpers_1 = require("../../../errors/errorHelpers");
+exports.onNotificationOpened = function (input) {
+    errorHelpers_1.assertIsInitialized();
+    return eventListeners_1.addEventListener('notificationOpened', input);
+};

package/lib/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/pushNotifications/providers/pinpoint/apis/onNotificationReceivedInBackground.js

@@ -0,0 +1,49 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@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}`);
+ * });
+ * ```
+ */
+exports.onNotificationReceivedInBackground = function () {
+    throw new utils_1.PlatformNotSupportedError();
+};

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

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

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

@@ -0,0 +1,10 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+var eventListeners_1 = require("../../../../eventListeners");
+var errorHelpers_1 = require("../../../errors/errorHelpers");
+exports.onNotificationReceivedInBackground = function (input) {
+    errorHelpers_1.assertIsInitialized();
+    return eventListeners_1.addEventListener('backgroundMessageReceived', input);
+};

package/lib/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/pushNotifications/providers/pinpoint/apis/onNotificationReceivedInForeground.js

@@ -0,0 +1,33 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@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);
+ * });
+ * ```
+ */
+exports.onNotificationReceivedInForeground = function () {
+    throw new utils_1.PlatformNotSupportedError();
+};

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

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

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

@@ -0,0 +1,10 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+var eventListeners_1 = require("../../../../eventListeners");
+var errorHelpers_1 = require("../../../errors/errorHelpers");
+exports.onNotificationReceivedInForeground = function (input) {
+    errorHelpers_1.assertIsInitialized();
+    return eventListeners_1.addEventListener('foregroundMessageReceived', input);
+};

package/lib/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/pushNotifications/providers/pinpoint/apis/onTokenReceived.js

@@ -0,0 +1,34 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@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);
+ * });
+ * ```
+ */
+exports.onTokenReceived = function () {
+    throw new utils_1.PlatformNotSupportedError();
+};

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

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

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

@@ -0,0 +1,10 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+var eventListeners_1 = require("../../../../eventListeners");
+var errorHelpers_1 = require("../../../errors/errorHelpers");
+exports.onTokenReceived = function (input) {
+    errorHelpers_1.assertIsInitialized();
+    return eventListeners_1.addEventListener('tokenReceived', input);
+};

package/lib/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/pushNotifications/providers/pinpoint/apis/requestPermissions.js

@@ -0,0 +1,38 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@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
+ * });
+ * ```
+ */
+exports.requestPermissions = function () {
+    throw new utils_1.PlatformNotSupportedError();
+};

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

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