@mpgd/adapter-capacitor 0.10.1 → 0.11.0

package/README.md

@@ -184,25 +184,132 @@ Games do not call the provider from a scene: `createGameServicesClient` from
 
 ## Notifications v2
 
-The notifications v2 provider arrives in PR P2 of the
-[notifications RFC](../../docs/specs/notifications/notifications-v2-rfc.md),
-together with the registry surface through which a provider serves the
-`notifications.v2.*` methods. Until then the gateway exposes no
-`notificationsV2`, and its request path never forwards a `notifications.v2.*`
-method to the base plugin: it answers `NOTIFICATIONS_V2_UNAVAILABLE`, which is
-not retryable, before it pauses the game. A provider cannot declare those
-methods in `methods`.
-
-Once P2 lets a provider serve `notifications.v2.*` methods, these rules apply:
-
-- `notifications.v2.requestPermission` and `notifications.v2.openSettings`
-  pause the game while they run, like `notifications.requestSubscription` and
-  `commerce.v2.requestPurchase`.
-- The provider registry passes `notifications.v2.*` through `assertMethodReady`
-  without a readiness check, as it does `commerce.v2.*`, so the provider's own
-  `unsupported` or `action-required` answers reach the game as answers.
-- The gateway validates each answer before the game sees it. Until P2 adds the
-  notifications v2 answers to that check, it rejects every one of them.
+`@mpgd/adapter-capacitor/notifications` is the Android and iOS provider of the
+[notifications RFC](../../docs/specs/notifications/notifications-v2-rfc.md#profile-capacitor).
+Only this subpath loads the notifications validators and the two plugins, so a
+game without notifications bundles neither.
+
+```ts
+import { resolveNotificationTopicsForTarget } from '@mpgd/catalog';
+import {
+  createCapacitorNotificationServiceProvider,
+  loadCapacitorNotificationSdks,
+} from '@mpgd/adapter-capacitor/notifications';
+
+const sdks = await loadCapacitorNotificationSdks();
+const notifications = createCapacitorNotificationServiceProvider({
+  platform: 'android',
+  topics: resolveNotificationTopicsForTarget(catalog, 'android'),
+  ...sdks,
+  // Optional: opens this app's notification settings (see below).
+  openSettings,
+});
+const gateway = createCapacitorPlatformGateway({ ..., providers: [notifications] });
+```
+
+Create it once, early in startup: it registers its native listeners when it
+is created, which is how a cold-start open reaches it.
+
+- **Plugins.** Install `@capacitor-firebase/messaging` (with the `firebase`
+  package its web fallback imports) and `@capacitor/local-notifications` 8.x,
+  both optional peers of this package. Do not also install
+  `@capacitor/push-notifications`: on iOS both claim Capacitor's single push
+  handler. `loadCapacitorNotificationSdks` imports them dynamically and leaves
+  one out when the app is not native, the shell has no native implementation,
+  or the import fails. Without both the provider is `unsupported`; without the
+  push plugin it declares no remote delivery; without the local plugin it
+  declares no local reminders and reads the permission through the push
+  plugin, which answers `granted` on Android 12 and lower whatever the setting
+  is. **Advertising needs both plugins:** the opt-out action every advertising
+  push carries is registered through the local plugin, so a push-only shell
+  whose catalog maps an advertising topic is `configuration-required` (its
+  reads, requests, and `register()` throw `NOTIFICATIONS_CONFIGURATION_REQUIRED`).
+  iOS remote notifications go through FCM, which relays to APNs.
+- **Gateway.** `createCapacitorNotificationServiceProvider` (or
+  `createNotificationServiceProvider` over another provider) registers the
+  nine `notifications.v2.*` methods. The gateway then exposes
+  `notificationsV2`, validates every payload and answer on both sides of its
+  in-process bridge, pauses the game under `requestPermission` and until the
+  player is back from `openSettings`, and serves the v1 `notifications`
+  adapter from the same provider. `getCapabilities()` carries the provider's
+  `notifications` block, and `providerAvailability.pushNotifications` equals
+  its availability. A v1 `pushNotifications` provider cannot be registered
+  next to it. Without a notifications service the gateway exposes no
+  `notificationsV2` and answers every `notifications.v2.*` request with
+  `NOTIFICATIONS_V2_UNAVAILABLE` before it pauses the game.
+- **Permission.** One OS permission for the app. The provider reads it through
+  the local plugin, which reflects the system setting on Android 12 and lower
+  where the push plugin answers `granted` regardless. The OS `denied` reads
+  `blocked`: after one denial on iOS (`promptLimit` 1) and after the second on
+  Android 13+ (`promptLimit` 2; pass `androidPromptLimit: 1` for an app that
+  targets SDK 32 or lower). Only `requestPermission` shows the dialog, and a
+  request made while the dialog is up shares its answer. A change made in
+  system settings is read on the next read and announced as
+  `permission-changed` when the app returns to the foreground.
+- **Local reminders.** `scheduleLocal` answers `unsupported` for a topic
+  outside the resolved catalog and for an advertising topic, which never
+  schedules locally. Otherwise it reads the permission first and answers
+  `permission-required` without calling the plugin, whose own `schedule` would
+  prompt on Android 13+.
+  - Reminders are inexact (`isExactNotification: false`; the plugin's default
+    would open the exact-alarm settings screen) but may fire in Android's Doze
+    mode (`allowWhileIdle: true`; Android lets such alarms fire about once per
+    nine minutes per app). Remove `SCHEDULE_EXACT_ALARM`, which the
+    plugin's manifest adds, from the merged manifest (`tools:node="remove"`).
+  - Each is keyed by a stable 32-bit native id, replaced by key, and posted on
+    the topic's Android channel. Operations run one at a time, in call order.
+  - iOS keeps at most 64 pending, so the provider keeps the nearest: at the
+    ceiling it cancels the farthest of its reminders before it schedules a
+    nearer one, and puts the farthest back when that schedule fails. Android
+    declares no ceiling, but its alarm manager refuses an app with about 500
+    pending alarms.
+- **Channels.** Each topic posts to its mapping's `channelId`, or to
+  `mpgd-service`, `mpgd-requested`, or `mpgd-advertising` by purpose
+  (`capacitorNotificationChannelId`). Creating the provider throws when a
+  channel would mix advertising with other topics, so a player can always turn
+  advertising off in system settings. Name the channels with the `channels`
+  option.
+- **Topics.** Only topics this target maps count. A topic the catalog does
+  not declare, or declares without a mapping for the target, reads
+  `unsupported`, answers `unavailable` to a request and `unsupported` to
+  `scheduleLocal`, gets no channel, and an open naming it carries no topic.
+- **Opens.** A tap becomes one `opened` event, kept whenever no listener is
+  attached (before the first subscriber, and between two) for the next
+  subscriber, as are endpoint and permission changes; a receipt that arrives
+  between two subscribers is dropped. A push carries its topic and route in
+  the data keys `topic` and `route` (`capacitorNotificationDataKeys`); its
+  other string entries, except
+  the transport's own keys (`from`, `collapse_key`, `google.*`, `gcm.*`, and
+  the like), reach the game as untrusted `data`. A route is kept only when
+  `isRootRelativeNotificationRoute` accepts it, and a topic only when the
+  catalog declares it. Nothing is granted from an open. An open that arrives
+  before the first subscriber is marked `cold`; Capacitor replays a cold-start
+  tap asynchronously, so one replayed after the game subscribed reads `warm`.
+- **Advertising opt-out.** For a catalog with an advertising topic, the
+  provider registers the action type `mpgd-advertising`
+  (`capacitorAdvertisingActionTypeId`) with the `advertising-opt-out` action
+  (title `advertisingOptOutTitle`, '수신거부' by default) through the local
+  plugin.
+  - On iOS that sets the app's notification categories, all at once, so it
+    replaces categories the shell registered through the same plugin. An FCM
+    send names the category in `apns.payload.aps.category`.
+  - The action opens the `optOutRoute` of the advertising topic the push names
+    in its `topic` data key; without that key it opens nothing.
+  - An Android FCM notification message cannot carry actions, so an Android
+    advertising push needs the shell to render it natively with the action;
+    the template work for that is C1's.
+- **Settings.** Neither plugin opens the notification settings, so the shell
+  passes `openSettings` (for example a small native method); without it
+  `permission.settings` is `false` and `openSettings` answers `unavailable`.
+  The provider resolves `openSettings` only once the app is back in the
+  foreground, after at most two minutes (`settingsReturnTimeoutMs`), or after
+  five seconds when the app never left.
+- **Endpoints.** `register()` answers the FCM token with the device
+  permission, locale, and time zone, or `null` while Firebase cannot issue one
+  yet; a token Firebase issues later arrives as `endpoint-changed`. It
+  registers FCM tokens only: `fcm-installation` addresses are reserved,
+  because FCM HTTP v1 cannot send to a Firebase installation id and the
+  game-services FCM sender refuses them.
 
 ## App Store server-side transaction signatures
 

package/dist/bridge-events.d.ts

@@ -0,0 +1,7 @@
+/**
+* Whether `envelope` names a protocol other than `protocol`. A channel may
+* carry several protocols, and another protocol is not this consumer's to
+* judge, so it is skipped. An envelope without a protocol string is
+* malformed and is not skipped: it must reach the consumer's validator.
+*/
+export declare function namesOtherProtocol(envelope: unknown, protocol: string): boolean;

package/dist/bridge-events.js

@@ -0,0 +1,14 @@
+// How the adapter's event channels filter envelopes. Internal: the package
+// entry does not export this module.
+/**
+ * Whether `envelope` names a protocol other than `protocol`. A channel may
+ * carry several protocols, and another protocol is not this consumer's to
+ * judge, so it is skipped. An envelope without a protocol string is
+ * malformed and is not skipped: it must reach the consumer's validator.
+ */
+export function namesOtherProtocol(envelope, protocol) {
+    const named = typeof envelope === 'object' && envelope !== null
+        ? envelope.protocol
+        : undefined;
+    return typeof named === 'string' && named !== protocol;
+}

package/dist/commerce-bridge.js

@@ -1,6 +1,7 @@
 import { bridgeCommerceEventProtocol, createBridgeError, isBridgeCommerceV2Method, } from '@mpgd/bridge';
 import { PlatformOperationError } from '@mpgd/platform';
 import { assertCommerceBridgeFetchProductsPayload, assertCommerceBridgeFetchProductsResult, assertCommerceBridgeFinishTransactionPayload, assertCommerceBridgeFinishTransactionResult, assertCommerceBridgeGetAvailablePurchasesPayload, assertCommerceBridgeGetAvailablePurchasesResult, assertCommerceBridgeGetCapabilitiesPayload, assertCommerceBridgeGetCapabilitiesResult, assertCommerceBridgeRequestPurchasePayload, assertCommerceBridgeRequestPurchaseResult, assertCommerceBridgeRestorePurchasesPayload, assertCommerceBridgeRestorePurchasesResult, assertCommerceEventEnvelope, CommerceError, commerceErrorInfoOf, commerceProtocol, commerceProtocolVersion, } from '@mpgd/platform/commerce';
+import { namesOtherProtocol } from './bridge-events.js';
 import { normalizeStoreSdkError } from './store-sdk.js';
 /** Bridge error for a commerce v2 payload the typia assert rejected. */
 export const commerceV2InvalidPayloadBridgeErrorCode = 'COMMERCE_V2_INVALID_PAYLOAD';
@@ -209,10 +210,7 @@ export function createBridgeCommerceProvider(input) {
                 // Another protocol on a shared event channel is not ours to judge; an
                 // envelope without a protocol is malformed and must reach the
                 // validator, as in the Apps in Toss provider.
-                const protocol = typeof envelope === 'object' && envelope !== null
-                    ? envelope.protocol
-                    : undefined;
-                if (typeof protocol === 'string' && protocol !== bridgeCommerceEventProtocol) {
+                if (namesOtherProtocol(envelope, bridgeCommerceEventProtocol)) {
                     return;
                 }
                 let event;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { type PlatformGateway, type PlatformTarget, type ViewportAdapter } from '@mpgd/platform';
 import { type CapacitorAppEventsApi, type CapacitorIncomingUrlKind, type CapacitorVisibilitySource } from './app-events.js';
 import { type CapacitorServiceProvider, type NativeBridge } from './providers.js';
-export { createCapacitorProviderRegistry, createDegradedCommerceCapabilities, type CapacitorCommerceServiceProvider, type CapacitorProviderCapabilitySnapshot, type CapacitorProviderRegistry, type CapacitorServiceProvider, type NativeBridge, } from './providers.js';
+export { createCapacitorProviderRegistry, createDegradedCommerceCapabilities, createDegradedNotificationCapabilities, type CapacitorCommerceServiceProvider, type CapacitorNotificationServiceProvider, type CapacitorNotificationsV2Service, type CapacitorProviderCapabilitySnapshot, type CapacitorProviderRegistry, type CapacitorServiceProvider, type NativeBridge, } from './providers.js';
 export { assertCommerceBridgeResult, commerceV2InvalidPayloadBridgeErrorCode, commerceV2MethodUnsupportedBridgeErrorCode, createBridgeCommerceProvider, createCommerceProviderBridge, createCommerceServiceProvider, type CommerceProviderBridge, type CreateBridgeCommerceProviderInput, type CreateCommerceProviderBridgeInput, type CreateCommerceServiceProviderInput, } from './commerce-bridge.js';
 export { createStoreCommerceProvider, recoverableErrorCodes, type CreateStoreCommerceProviderInput, type StoreCommerceCapabilityOverrides, type StoreCommerceProductMapping, type StoreCommerceProvider, } from './store-commerce-provider.js';
 export { defaultStoreSdkErrorCodeMap, normalizeStoreSdkError, type StoreSdk, type StoreSdkCapabilities, type StoreSdkError, type StoreSdkErrorCodeMap, type StoreSdkEvent, type StoreSdkEventName, type StoreSdkEventOf, type StoreSdkFetchProductsInput, type StoreSdkFinishTransactionInput, type StoreSdkFinishTransactionResult, type StoreSdkGetAvailablePurchasesInput, type StoreSdkProduct, type StoreSdkPurchase, type StoreSdkRequestPurchaseInput, type StoreSdkRequestPurchaseResult, } from './store-sdk.js';

package/dist/index.js

@@ -1,13 +1,14 @@
-import { bridgeCommerceEventProtocol, decodeBridgeCredentialLoadData, decodeBridgeStorageLoadData, } from '@mpgd/bridge';
+import { bridgeCommerceEventProtocol, bridgeNotificationsEventProtocol, decodeBridgeCredentialLoadData, decodeBridgeStorageLoadData, } from '@mpgd/bridge';
 import { CapacitorGameServices } from '@mpgd/capacitor-game-services';
 import { PlatformOperationError, } from '@mpgd/platform';
 import { withShareIntentCheck } from '@mpgd/platform/routes';
 import { createCapacitorAppEvents, } from './app-events.js';
+import { namesOtherProtocol } from './bridge-events.js';
 import { createBridgeCommerceProvider } from './commerce-bridge.js';
 import { assertProviderResponseData, createCapacitorProviderRegistry, } from './providers.js';
 import { assertNotificationsV2Served, externalActivityMethods } from './request-policy.js';
 import { createCapacitorViewport } from './viewport.js';
-export { createCapacitorProviderRegistry, createDegradedCommerceCapabilities, } from './providers.js';
+export { createCapacitorProviderRegistry, createDegradedCommerceCapabilities, createDegradedNotificationCapabilities, } from './providers.js';
 export { assertCommerceBridgeResult, commerceV2InvalidPayloadBridgeErrorCode, commerceV2MethodUnsupportedBridgeErrorCode, createBridgeCommerceProvider, createCommerceProviderBridge, createCommerceServiceProvider, } from './commerce-bridge.js';
 export { createStoreCommerceProvider, recoverableErrorCodes, } from './store-commerce-provider.js';
 export { defaultStoreSdkErrorCodeMap, normalizeStoreSdkError, } from './store-sdk.js';
@@ -66,15 +67,25 @@ export function createCapacitorPlatformGateway(input) {
             // else, a malformed envelope included, reaches the commerce
             // provider's validator.
             subscribe: (listener) => commerceProvider.bridge.subscribe((envelope) => {
-                const protocol = typeof envelope === 'object' && envelope !== null
-                    ? envelope.protocol
-                    : undefined;
-                if (typeof protocol === 'string' && protocol !== bridgeCommerceEventProtocol) {
-                    return;
+                if (!namesOtherProtocol(envelope, bridgeCommerceEventProtocol)) {
+                    listener(envelope);
                 }
-                listener(envelope);
             }),
         });
+    const notificationsProvider = providers.notifications;
+    // Served through the same request path as every other provider method, as
+    // commerce is, so the game pauses under the permission dialog and the
+    // settings screen, and every answer is validated on the way back.
+    const notificationSurface = notificationsProvider?.notificationsV2.createGatewaySurface({
+        request: (method, payload) => request(method, payload),
+        // Only an envelope that names another protocol is dropped; anything else,
+        // a malformed envelope included, reaches the client's validator.
+        subscribe: (listener) => notificationsProvider.bridge.subscribe((envelope) => {
+            if (!namesOtherProtocol(envelope, bridgeNotificationsEventProtocol)) {
+                listener(envelope);
+            }
+        }),
+    });
     const lifecycle = createCapacitorAppEvents({
         target: input.target,
         ...(input.app === undefined ? {} : { app: input.app }),
@@ -226,7 +237,7 @@ export function createCapacitorPlatformGateway(input) {
                 });
             }
             if (provider !== undefined) {
-                assertProviderResponseData(method, response.data);
+                assertProviderResponseData(method, response.data, provider);
             }
             return response.data;
         }
@@ -247,12 +258,14 @@ export function createCapacitorPlatformGateway(input) {
             const base = await request('runtime.getCapabilities', {});
             // A native shell built before the commerce v2 removals may still send the
             // retired boolean flags; the commerce block is the only commerce source.
-            const { nativeIap: _retiredNativeIap, subscriptionIap: _retiredSubscriptionIap, ...native } = (isRecord(base) ? base : {});
+            // The notifications block is the registered service's, present exactly
+            // when the gateway exposes `notificationsV2`.
+            const { nativeIap: _retiredNativeIap, subscriptionIap: _retiredSubscriptionIap, notifications: _nativeNotifications, ...native } = (isRecord(base) ? base : {});
             // One bounded registry read serves the feature states and the commerce
             // block, so a stalled or invalid provider degrades the snapshot instead
             // of rejecting it, and a missing or invalid native `commerce` answer is
             // always replaced by the provider's block or the unsupported block.
-            const { availability: states, commerce: commerceCapabilities } = await providers.getCapabilitySnapshot();
+            const { availability: states, commerce: commerceCapabilities, notifications: notificationCapabilities, } = await providers.getCapabilitySnapshot();
             const rewardedAds = states.rewardedAds === 'available';
             const interstitialAds = states.interstitialAds === 'available';
             const bannerAds = states.bannerAds === 'available';
@@ -265,6 +278,9 @@ export function createCapacitorPlatformGateway(input) {
                 nativeLeaderboard: states.nativeLeaderboard === 'available',
                 providerAvailability: states,
                 commerce: commerceCapabilities,
+                ...(notificationSurface === undefined || notificationCapabilities === undefined
+                    ? {}
+                    : { notifications: notificationCapabilities }),
             };
         },
         ...(commerce === undefined ? {} : { commerce }),
@@ -283,10 +299,15 @@ export function createCapacitorPlatformGateway(input) {
             share: (payload) => request('share.share', payload),
             readInboundShare: () => request('share.readInboundShare', {}),
         }),
-        notifications: {
+        // With a notifications v2 service, v1 is served from it (RFC
+        // "Capabilities"), so both report the same readiness.
+        notifications: notificationSurface?.notifications ?? {
             getStatus: (topic) => request('notifications.getStatus', { topic }),
             requestSubscription: (topic) => request('notifications.requestSubscription', { topic }),
         },
+        ...(notificationSurface === undefined
+            ? {}
+            : { notificationsV2: notificationSurface.notificationsV2 }),
         ads: {
             ...(adProvider === undefined ? {} : { provider: adProvider }),
             preload: (payload) => request('ads.preload', payload),

package/dist/notifications-bridge.d.ts

@@ -0,0 +1,82 @@
+import { type BridgeEvent, type BridgeNotificationsEvent, type BridgeNotificationsV2Method, type BridgeRequest, type BridgeResponse } from '@mpgd/bridge';
+import { type NotificationSubscriptionAdapter } from '@mpgd/platform';
+import { type NotificationProvider, type NotificationProviderId, type NotificationTopicDeclaration } from '@mpgd/platform/notifications';
+import type { CapacitorNotificationServiceProvider } from './providers.js';
+export interface NotificationProviderBridge {
+  request(input: BridgeRequest): Promise<BridgeResponse>;
+  /** Delivers `{ protocol: 'mpgd.notifications.v2', sequence, event }`, numbered from 0. */
+  subscribe(listener: (event: BridgeEvent) => void): () => void;
+}
+export interface CreateNotificationProviderBridgeInput {
+  readonly provider: NotificationProvider;
+}
+/**
+* In-process `NativeBridge` over a notifications v2 provider. Each
+* `notifications.v2.*` request validates its payload (a payload the contract
+* rejects answers `NOTIFICATIONS_INVALID_INPUT`) and its answer (one the
+* contract rejects answers `NOTIFICATIONS_CONFIGURATION_REQUIRED`, because the
+* provider broke it). A method the
+* provider does not implement answers `NOTIFICATIONS_UNSUPPORTED`, except
+* `openSettings`, which answers `unavailable`. Events go out through
+* `createBridgeEventSource`, which attaches to the provider only for the
+* first listener, so events the provider buffered reach it. Any other method
+* answers `UNSUPPORTED_METHOD`.
+*/
+export declare function createNotificationProviderBridge(input: CreateNotificationProviderBridgeInput): NotificationProviderBridge;
+export interface CreateNotificationServiceProviderInput {
+  readonly id: string;
+  readonly notifications: NotificationProvider;
+  /**
+  * The topics resolved for the target, as the provider was created with
+  * them: the v1 adapter answers `configuration-required` for a topic outside
+  * them, and so for an entry that still carries a catalog's `targets`,
+  * which names no single target.
+  */
+  readonly topics: readonly Pick<NotificationTopicDeclaration, 'id'>[];
+}
+/**
+* Registry entry for a notifications v2 provider, as
+* `createCommerceServiceProvider` is for commerce: it declares no feature and
+* no method, the nine `notifications.v2.*` methods are implied and served in
+* process by `createNotificationProviderBridge`, and the gateway exposes
+* `notificationsV2` and a v1 `notifications` adapter served from it.
+*/
+export declare function createNotificationServiceProvider(input: CreateNotificationServiceProviderInput): CapacitorNotificationServiceProvider;
+/**
+* The v1 `NotificationSubscriptionAdapter` served from a v2 provider whose
+* host is readable (RFC "Migration and PR plan" table, through
+* `toNotificationSubscriptionAdapter`): every state comes from the host, a
+* topic outside `topics` reads `configuration-required` and requests
+* `unavailable`.
+*/
+export declare function createNotificationSubscriptionAdapter(provider: Pick<NotificationProvider, 'getPermission' | 'requestPermission'>, topics: readonly Pick<NotificationTopicDeclaration, 'id'>[]): NotificationSubscriptionAdapter;
+export interface CreateBridgeNotificationProviderInput {
+  readonly provider: NotificationProviderId;
+  /** The optional methods the serving provider implements; `openSettings` is always present. */
+  readonly serves: {
+    readonly revokePermission: boolean;
+    readonly register: boolean;
+    /** `scheduleLocal`, `cancelLocal`, and `listLocal`. */
+    readonly local: boolean;
+  };
+  /** Sends one bridge request; the gateway's `request` fits. */
+  readonly request: <TData>(method: BridgeNotificationsV2Method, payload: unknown) => Promise<TData>;
+  readonly subscribe: (listener: (event: BridgeNotificationsEvent) => void) => () => void;
+}
+/**
+* `NotificationProvider` over a bridge that serves the `notifications.v2.*`
+* methods and the event envelope. Answers are validated again on this side,
+* so a transport that forgets to stays fail-closed. A bridge failure becomes
+* a `NotificationError`: one with a notifications code keeps it, anything
+* else is `NOTIFICATIONS_TEMPORARILY_UNAVAILABLE` with the failure's
+* retryable flag. An answer the contract rejects is
+* `NOTIFICATIONS_CONFIGURATION_REQUIRED`, which is not retryable, because the
+* provider broke the contract. An event envelope that
+* names another protocol is skipped; a malformed one is dropped with a
+* warning, because it carries nothing the game could route.
+*
+* Events reach the listeners subscribed when they arrive. The Capacitor
+* provider keeps events that arrive while no listener is attached for the
+* next subscriber, so a game that subscribes per scene loses no open.
+*/
+export declare function createBridgeNotificationProvider(input: CreateBridgeNotificationProviderInput): NotificationProvider;