openfin-notifications 1.25.1 → 2.0.0-alpha-2680

package/README.md

@@ -2,6 +2,8 @@
 
 # OpenFin Notification Center
 
+### This library is deprecated. We will stop publishing updates to it after July 2024. Use [@openfin/workspace/notifications](https://www.npmjs.com/package/@openfin/workspace) instead.
+
 ## Overview
 
 The OpenFin Notification Center provides developers with a uniform way to create, display and organize desktop notifications as well as responding to notification events.

package/dist/client/EventRouter.d.ts

@@ -6,7 +6,7 @@
  * Acts as a central point for routing all events received from the provider.
  */
 import { EventEmitter } from 'events';
-import { TransportMappings, TransportMemberMappings } from './internal';
+import { TransportMappings, TransportMemberMappings, Events } from './internal';
 export interface EventSpecification {
     type: string;
 }
@@ -41,4 +41,9 @@ export declare class EventRouter<E extends EventSpecification> {
     registerDeserializer<T extends E>(eventType: T['type'], deserializer: EventDeserializer<E, T>): void;
     dispatchEvent<T extends E>(event: Targeted<Transport<T>>): void;
 }
+/**
+ * The event emitter to emit events received from the service.  All addEventListeners will tap into this.
+ */
+export declare const eventEmitter: EventEmitter;
+export declare function getEventRouter(): EventRouter<Events>;
 export {};

package/dist/client/actions.d.ts

@@ -96,7 +96,7 @@
  *
  * @hidden
  */
-import { CustomData } from '.';
+import { CustomData } from './main';
 /**
  * Denotes a field as being an action. Defining this field (with a non-`undefined` value) will result in actions being
  * raised and sent back to the source application when the corresponding event happens.
@@ -104,12 +104,8 @@ import { CustomData } from '.';
  * For example, providing a value for the `onClick` field of {@link ButtonOptions} will result in a
  * {@link NotificationActionEvent|`notification-action`} event being fired when that button is clicked.
  *
- * In the current version of the service, the `NotificationActionResult`s returned back to an application are static
- * and must bedefined at the point where the notification is created. Later versions of the service will allow some
- * limited programmatic creation of these results, for use in situations where static result data isn't sufficient.
- *
- * The generic parameters of this type are for future expansion. Future versions of the service will allow for more
- * control over the handling of actions.
+ * The `NotificationActionResult returned back to an application is static
+ * and must be defined at the point where the notification is created.
  */
 export declare type ActionDeclaration<T extends never, E extends never> = NotificationActionResult;
 /**
@@ -120,7 +116,7 @@ export declare type ActionDeclaration<T extends never, E extends never> = Notifi
  * Since this type is entirely application-specific, the type  is used in these definitions. However, there is an
  * optional generic argument here, which can be used if an application were to define its own conventions for the shape
  * of this field (which is recommended). To make use of this, define a `notification-action` handler that includes the
- * application-defined type as a template argument. This type is then propogated up to {@link NotificationActionEvent}.
+ * application-defined type as a template argument. This type is then propagated up to {@link NotificationActionEvent}.
  * The example below demonstrates this, using the same use-case as at the top of this page.
  *
  * ```ts
@@ -153,8 +149,7 @@ export declare type NotificationActionResult<T = CustomData> = T;
  */
 export declare enum ActionTrigger {
     /**
-     * The user interacted with one of the controls within the notification. This currently means a button click, but
-     * other control types will be added in future releases.
+     * The user interacted with one of the controls in the notification: a button or an actionable fragment.
      */
     CONTROL = "control",
     /**
@@ -173,7 +168,7 @@ export declare enum ActionTrigger {
     /**
      * The action was triggered programmatically by an application.
      *
-     * *Not currently supported - will be implemented in a future release*
+     * *Not currently supported*
      */
     PROGRAMMATIC = "programmatic"
 }

package/dist/client/auto-launch.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/client/channel-client.d.ts

@@ -0,0 +1,7 @@
+import type OpenFin from '@openfin/core';
+export declare const initAwaitedChannelClient: () => {
+    channelClientPromise: Promise<OpenFin.ChannelClient>;
+    isInit: boolean;
+};
+export declare const clearAwaitedChannelClient: () => void;
+export declare const getChannelClient: () => Promise<OpenFin.ChannelClient>;

package/dist/client/channel-client.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/client/connection.d.ts

@@ -1,24 +1,7 @@
-/// <reference types="node" />
 import type OpenFin from '@openfin/core';
-/**
- * @hidden
- */
-/**
- * File contains vars used to establish service connection between client and provider.
- *
- * These are separated out from 'internal.ts' as including these from provider code will cause the provider to connect
- * to itself.
- *
- * These types are a part of the client, but are not required by applications wishing to interact with the service.
- * This file is excluded from the public-facing TypeScript documentation.
- */
-import { EventEmitter } from 'events';
-import { APITopic, API, Events } from './internal';
-import { EventRouter } from './EventRouter';
-/**
- * The event emitter to emit events received from the service.  All addEventListeners will tap into this.
- */
-export declare const eventEmitter: EventEmitter;
+import { APITopic, API } from './internal';
+export declare function connectToNotifications(): void;
+export declare function launchSystemApp(): Promise<void>;
 export declare function getServicePromise(): Promise<OpenFin.ChannelClient>;
 /**
  * Wrapper around service.dispatch to help with type checking
@@ -26,4 +9,3 @@ export declare function getServicePromise(): Promise<OpenFin.ChannelClient>;
  * @param payload Data payload to send to the provider.
  */
 export declare function tryServiceDispatch<T extends APITopic>(action: T, payload: API[T][0]): Promise<API[T][1]>;
-export declare function getEventRouter(): EventRouter<Events>;

package/dist/client/controls.d.ts

@@ -1,10 +1,7 @@
 /**
- * Notifications allow additional UI components to be specified by applications. The service will control the
+ * Notifications allow additional UI components to be specified by applications. The service controls the
  * positioning and styling of these components.
  *
- * In this version of the service, only buttons are supported. Additional control types will be added in future
- * releases.
- *
  * @module Controls
  */
 /**
@@ -39,11 +36,8 @@ export declare type ControlOptions = Required<PrimaryControlOptions | WithExplic
  */
 export interface ButtonOptions {
     /**
-     * Identifies the type of this control. Additional control types will be added in future versions of the service.
-     *
-     * This type declaration is optional, as the other control types will be declared in a slightly different way.
-     * Whilst this field is optional when specifiying options, it will be added by the service during creation (see
-     * {@link create}) - meaning it will always be present when receiving a `notification-action` event from a button.
+     * The type of the control. Optional, added automatically if `NotificationOptions.buttons` includes the `onClick`
+     * property and therefore generates a `notification-action` event.
      */
     type?: 'button';
     /**

package/dist/client/index.d.ts

@@ -1,392 +1,2 @@
-/**
- * @module NotificationCenter
- */
-/**
- * Need a comment block here so that the comment block above is interpreted as a file comment, and not a comment on the
- * import below.
- *
- * @hidden
- */
-import { NotificationActionResult, ActionTrigger } from './actions';
-import { ButtonOptions, ControlOptions } from './controls';
-import { DistributiveOmit } from './internal';
-import * as provider from './provider';
-import { NotificationSource } from './source';
-import { NotificationIndicator, IndicatorType, IndicatorColor } from './indicator';
-import { NotificationOptions } from './templates/templates';
-import { UpdatableNotificationOptions } from './templates/update';
-import * as actions from './actions';
-export * from './actions';
-export * from './controls';
-export * from './source';
-export * from './forms';
-export * from './stream';
-export * from './templates';
-export * from './platform';
-export { actions, provider, NotificationOptions };
-export { NotificationIndicator, IndicatorColor, IndicatorType as NotificationIndicatorType };
-/**
- * The Notification Client library's version in semver format.
- *
- * This is the version which you are currently using.
- */
-export declare const VERSION: string;
-/**
- * Application-defined context data that can be attached to buttons on notifications.
- */
-export declare type CustomData = Record<string, any>;
-/**
- * A fully-hydrated form of {@link NotificationOptions}.
- *
- * After {@link create|creating} a notification, the service will return an object of this type. This will be the given
- * options object, with any unspecified fields filled-in with default values.
- *
- * This object should be treated as immutable. Modifying its state will not have any effect on the notification or the
- * state of the service.
- */
-export declare type Notification<T extends NotificationOptions = NotificationOptions> = Readonly<Required<DistributiveOmit<T, 'buttons'>> & {
-    readonly buttons: ReadonlyArray<Required<ButtonOptions>>;
-}>;
-export declare type UpdatableNotification<T extends UpdatableNotificationOptions = UpdatableNotificationOptions> = Readonly<DistributiveOmit<T, 'buttons'> & {
-    readonly buttons?: ReadonlyArray<Required<ButtonOptions>>;
-}>;
-/**
- * Event fired when an action is raised for a notification due to a specified trigger. It is important to note that
- * applications will only receive these events if they indicate to the service that they want to receive these events.
- * See {@link actions} for a full example of how actions are defined, and how an application can listen to and handle
- * them.
- *
- * This can be fired due to interaction with notification buttons or the notification itself, the notification being
- * closed (either by user interaction or by API call), or by the notification expiring. Later versions of the service
- * will add additional control types that may raise actions from user interaction. All actions, for all control types,
- * will be returned to the application via the same `notification-action` event type.
- *
- * The event object will contain the application-defined {@link NotificationActionResult|metadata} that allowed this
- * action to be raised, and details on what triggered this action and which control the user interacted with.
- *
- * Unlike other event types, `notification-action` events will be buffered by the service until the application has
- * added a listener for this event type, at which point it will receive all buffered `notification-action` events. The
- * service will also attempt to restart the application if it is not running when the event is fired.
- *
- * This type includes a generic type argument, should applications wish to define their own interface for action
- * results. See {@link NotificationActionResult} for details.
- *
- * @event "notification-action"
- */
-export interface NotificationActionEvent<T = CustomData> {
-    type: 'notification-action';
-    /**
-     * The notification that created this action
-     */
-    notification: Readonly<Notification>;
-    /**
-     * This property allows the application handling the action to identify where this notification originated.
-     */
-    source: NotificationSource;
-    /**
-     * Indicates what triggered this action.
-     *
-     * Note that the `programmatic` trigger is not yet implemented.
-     */
-    trigger: ActionTrigger;
-    /**
-     * The control whose interaction resulted in this action being raised. Will only be present when {@link trigger} is
-     * {@link ActionTrigger.CONTROL}.
-     *
-     * Future versions of the service will add additional controls beyond buttons, and interactions with these new
-     * control types will also come through this one event type. For best forward-compatibility, applications should
-     * always check the `type` property of this control, and not assume that the type will always be `'button'`.
-     *
-     * This field is marked optional as future versions of the service will also include alternate methods of raising
-     * `notification-action` events that do not originate from a button or other control.
-     *
-     * When present, the object here will always be strictly equal to one of the control definitions within
-     * `notification`. This means `indexOf` checks and other equality checks can be performed on this field if
-     * required, such as:
-     *
-     * ```ts
-     * function onNotificationAction(event: NotificationActionEvent): void {
-     *     if (event.control && event.control.type === 'button') {
-     *         const butttonIndex = event.notification.buttons.indexOf(event.control);
-     *
-     *         // Handle button click
-     *         // . . .
-     *     }
-     * }
-     * ```
-     */
-    control?: Readonly<ControlOptions>;
-    /**
-     * Application-defined metadata that this event is passing back to the application.
-     *
-     * A `notification-action` event is only fired for a given trigger if the
-     * {@link NotificationOptions|notification options} included an action result for that trigger.
-     *
-     * See the comment on the {@link NotificationActionEvent} type for an example of buttons that do and don't raise
-     * actions.
-     */
-    result: NotificationActionResult<T>;
-}
-/**
- * Event fired whenever notification toast has been dismissed. This could be either by pressing notification dismiss `-` button or
- * by clicking notification body if BODY_CLICK action has been set to "dismiss_event".
- *
- * @event "notification-toast-dismissed"
- */
-export interface NotificationToastDismissedEvent {
-    type: 'notification-toast-dismissed';
-    notification: Notification;
-}
-/**
- * Event fired whenever the notification has been closed.
- *
- * This event is fired regardless of how the notification was closed - i.e.: via a call to `clear`/`clearAll`, the
- * notification expiring, or by a user clicking either the notification itself, the notification's close button, or
- * a button on the notification.
- *
- * @event "notification-closed"
- */
-export interface NotificationClosedEvent {
-    type: 'notification-closed';
-    /**
-     * The notification that has just been closed.
-     *
-     * This object will match what is returned from the `create` call when the notification was first created.
-     */
-    notification: Notification;
-}
-/**
- * Event fired whenever a new notification has been created.
- *
- * @event "notification-created"
- */
-export interface NotificationCreatedEvent {
-    type: 'notification-created';
-    /**
-     * The notification that has just been created.
-     *
-     * This object will match what is returned from the `create` call.
-     */
-    notification: Notification;
-}
-/**
- * Event fired whenever a reminder has been created either via the Notifications API
- * or by the user on the Notification Center UI
- *
- * @event "notification-reminder-created"
- */
-export interface NotificationReminderCreatedEvent {
-    type: 'notification-reminder-created';
-    /**
-     * The reminder notification that has just been created.
-     *
-     * This object will match what is returned from the `create` call when the notification
-     * was first created.
-     */
-    notification: Notification;
-    /**
-     * The reminder time-out timestamp.
-     */
-    reminderDate: Date;
-}
-/**
- * Event fired whenever a reminder has been canceled by the user, reminder notification is deleted or the reminder timeout has reached.
- *
- * @event "notification-reminder-removed"
- */
-export interface NotificationReminderRemovedEvent {
-    type: 'notification-reminder-removed';
-    /**
-     * The notification associated with the reminder that has just been removed.
-     *
-     * This object will match what is returned from the `create` call when the notification was first created.
-     */
-    notification: Notification;
-}
-/**
- * Event fired whenever the total number of notifications from **all** sources changes.
- *
- * @event "notifications-count-changed"
- */
-export interface NotificationsCountChanged {
-    type: 'notifications-count-changed';
-    /**
-     * Number of notifications in the Center.
-     */
-    count: number;
-}
-/**
- * Event fired whenever submit button is clicked on a notification form.
- *
- * @event "notifications-count-changed"
- */
-export interface NotificationFormSubmittedEvent {
-    type: 'notification-form-submitted';
-    notification: Notification;
-    form: Record<string, unknown>;
-}
-export declare function addEventListener(eventType: 'notification-form-submitted', listener: (event: NotificationFormSubmittedEvent) => void): void;
-export declare function addEventListener(eventType: 'notification-action', listener: (event: NotificationActionEvent) => void): void;
-export declare function addEventListener(eventType: 'notification-created', listener: (event: NotificationCreatedEvent) => void): void;
-export declare function addEventListener(eventType: 'notification-toast-dismissed', listener: (event: NotificationToastDismissedEvent) => void): void;
-export declare function addEventListener(eventType: 'notification-closed', listener: (event: NotificationClosedEvent) => void): void;
-export declare function addEventListener(eventType: 'notifications-count-changed', listener: (event: NotificationsCountChanged) => void): void;
-export declare function addEventListener(eventType: 'notification-reminder-created', listener: (event: NotificationReminderCreatedEvent) => void): void;
-export declare function addEventListener(eventType: 'notification-reminder-removed', listener: (event: NotificationReminderRemovedEvent) => void): void;
-export declare function removeEventListener(eventType: 'notification-form-submitted', listener: (event: NotificationFormSubmittedEvent) => void): void;
-export declare function removeEventListener(eventType: 'notification-action', listener: (event: NotificationActionEvent) => void): void;
-export declare function removeEventListener(eventType: 'notification-created', listener: (event: NotificationCreatedEvent) => void): void;
-export declare function removeEventListener(eventType: 'notification-toast-dismissed', listener: (event: NotificationToastDismissedEvent) => void): void;
-export declare function removeEventListener(eventType: 'notification-closed', listener: (event: NotificationClosedEvent) => void): void;
-export declare function removeEventListener(eventType: 'notifications-count-changed', listener: (event: NotificationsCountChanged) => void): void;
-export declare function removeEventListener(eventType: 'notification-reminder-created', listener: (event: NotificationReminderCreatedEvent) => void): void;
-export declare function removeEventListener(eventType: 'notification-reminder-removed', listener: (event: NotificationReminderRemovedEvent) => void): void;
-/**
- * Extended configuration options for the notification creation.
- */
-export interface NotificationCreationOptions {
-    /**
-     * The date on which the notification will be removed from reminders category and recreated
-     * created as regular notification.
-     *
-     * If this date is earlier than the notification creation time, the notification will be created
-     * immediately.
-     * Cannot be earlier than the expiry date, if set.
-     *
-     */
-    reminderDate?: Date;
-}
-/**
- * Creates a new notification.
- *
- * If a reminder is not set, the notification will immediately appear in the Notification Center and as a toast if the Center is not visible.
- * If a reminder is set, the notification will appear in the Center when the reminder date is reached.
- *
- * If a notification is created with an `id` of an already existing notification, the existing notification will be recreated with the new content.
- *
- * ```ts
- * import {create} from 'openfin-notifications';
- *
- * create({
- *      id: 'uniqueNotificationId',
- *      title: 'Notification Title',
- *      body: 'Text to display within the notification body',
- *      icon: 'https://openfin.co/favicon.ico'
- * }, {
- *      reminderDate: new Date('October 21, 2015 07:28:00');
- * });
- * ```
- *
- * @param options Notification configuration options.
- * @param creationOptions Extended configuration options for the notification creation.
- */
-export declare function create<T extends NotificationOptions>(options: T, creationOptions?: NotificationCreationOptions): Promise<Notification<T>>;
-/**
- * Updates an existing notification. Requires id of original Notification and one of:
- *    - buttons
- *    - customData
- *    - Template
- *
- * The updated Notification will then show in Notification Centre and in the Toast stack if not expired.
- *
- * Example:
- * ```ts
- * import {update} from 'openfin-notifications';
- *
- * update({
- *    id: uniqueNotificationId,
- *    body: 'i am an update! - ' + Date.now().toString(),
- *    template: 'markdown',
- * });
- * ```
- * @param options
- * @returns
- */
-export declare function update<T extends UpdatableNotificationOptions>(options: T): Promise<Notification>;
-/**
- * Clears a specific notification from the Notification Center.
- *
- * Returns true if the notification was successfully cleared.  Returns false if the notification was not cleared, without errors.
- *
- * ```ts
- * import {clear} from 'openfin-notifications';
- *
- * clear('uniqueNotificationId');
- * ```
- *
- * @param id ID of the notification to clear.
- */
-export declare function clear(id: string): Promise<boolean>;
-/**
- * Retrieves all Notifications which were created by the calling application, including child windows.
- *
- * ```ts
- * import {getAll} from 'openfin-notifications'
- *
- * getAll().then((notifications: Notification[]) => {
- *     console.log(`Service has ${notifications.length} notifications for this app:`, notifications);
- * });
- * ```
- *
- * There is deliberately no mechanism provided for fetching notifications that were created by a different application.
- */
-export declare function getAll(): Promise<Notification[]>;
-/**
- * Clears all Notifications which were created by the calling application, including child windows.
- *
- * Returns the number of successfully cleared Notifications.
- *
- * ```ts
- * import {clearAll} from 'openfin-notifications';
- *
- * clearAll();
- * ```
- */
-export declare function clearAll(): Promise<number>;
-/**
- * Toggles the visibility of the Notification Center.
- *
- * ```ts
- * import {toggleNotificationCenter} from 'openfin-notifications';
- *
- * toggleNotificationCenter();
- * ```
- */
-export declare function toggleNotificationCenter(): Promise<void>;
-/**
- * Options to modify the Notification Center behaviour when show() API is called.
- */
-export interface ShowOptions {
-    navigateToAll?: boolean;
-}
-/**
- * Sets the visibility of the Notification Center to true.
- *
- * ```ts
- * import { show } from 'openfin-notifications';
- *
- * show({ navigateToAll: false });
- * ```
- * @param showOptions
- */
-export declare function show(options?: ShowOptions): Promise<void>;
-/**
- * Sets the visibility of the Notification Center to false.
- *
- * ```ts
- * import { hide } from 'openfin-notifications';
- *
- * hide();
- * ```
- */
-export declare function hide(): Promise<void>;
-/**
- * Get the total count of notifications from **all** applications.
- *
- * ```ts
- * import {getNotificationsCount} from 'openfin-notifications';
- *
- * getNotificationsCount();
- * ```
- */
-export declare function getNotificationsCount(): Promise<number>;
+import './auto-launch';
+export * from './main';

package/dist/client/indicator.d.ts

@@ -4,8 +4,6 @@
 /**
  * @deprecated
  * Lists possible semantic use-cases for notifications, which can alter how the notification is presented to the user.
- *
- * Additional indicator types may be added in future releases.
  */
 export declare enum IndicatorType {
     FAILURE = "failure",

package/dist/client/internal.d.ts

@@ -1,4 +1,3 @@
-import type OpenFin from '@openfin/core';
 /**
  * @hidden
  */
@@ -11,7 +10,7 @@ import type OpenFin from '@openfin/core';
 import { NotificationActionResult, ActionTrigger } from './actions';
 import { ProviderStatus } from './provider';
 import { NotificationSource } from './source';
-import { NotificationOptions, Notification, NotificationActionEvent, NotificationClosedEvent, NotificationCreatedEvent, NotificationsCountChanged, NotificationFormSubmittedEvent, UpdatableNotification, NotificationPlatform, UpdatableNotificationOptions, NotificationToastDismissedEvent, ShowOptions, NotificationReminderCreatedEvent, NotificationReminderRemovedEvent, RegistrationMetaInfo, ImageTemplateFragment, ContainerTemplateFragment, ActionableTextTemplateFragment } from './index';
+import { NotificationOptions, Notification, NotificationActionEvent, NotificationClosedEvent, NotificationCreatedEvent, NotificationsCountChanged, NotificationFormSubmittedEvent, UpdatableNotification, UpdatableNotificationOptions, NotificationToastDismissedEvent, ShowOptions, NotificationReminderCreatedEvent, NotificationReminderRemovedEvent, ImageTemplateFragment, ContainerTemplateFragment, ActionableTextTemplateFragment, PlatformDeregisterPayload, PlatformRegisterPayload } from './main';
 /**
  * The identity of the main application window of the service provider
  */
@@ -34,10 +33,10 @@ export declare const enum APITopic {
     REMOVE_EVENT_LISTENER = "remove-event-listener",
     GET_PROVIDER_STATUS = "get-provider-status",
     GET_NOTIFICATIONS_COUNT = "get-notifications-count",
-    REGISTER_PLATFORM = "register-notifications-platform",
-    DEREGISTER_PLATFORM = "deregister-notifications-platform",
     SHOW_NOTIFICATION_CENTER = "show-notification-center",
-    HIDE_NOTIFICATION_CENTER = "hide-notification-center"
+    HIDE_NOTIFICATION_CENTER = "hide-notification-center",
+    REGISTER_PLATFORM = "register-notifications-platform",
+    DEREGISTER_PLATFORM = "deregister-notifications-platform"
 }
 export interface API {
     [APITopic.CREATE_NOTIFICATION]: [CreatePayload, NotificationInternal];
@@ -50,13 +49,13 @@ export interface API {
     [APITopic.REMOVE_EVENT_LISTENER]: [Events['type'], void];
     [APITopic.GET_PROVIDER_STATUS]: [undefined, ProviderStatus];
     [APITopic.GET_NOTIFICATIONS_COUNT]: [undefined, number];
+    [APITopic.SHOW_NOTIFICATION_CENTER]: [ShowPayload | undefined, void];
+    [APITopic.HIDE_NOTIFICATION_CENTER]: [undefined, void];
     [APITopic.REGISTER_PLATFORM]: [
         PlatformRegisterPayload,
         Pick<RegistrationMetaInfo, 'notificationsVersion'> | undefined
     ];
     [APITopic.DEREGISTER_PLATFORM]: [PlatformDeregisterPayload, void];
-    [APITopic.SHOW_NOTIFICATION_CENTER]: [ShowPayload | undefined, void];
-    [APITopic.HIDE_NOTIFICATION_CENTER]: [undefined, void];
 }
 export declare type Events = NotificationActionEvent | NotificationToastDismissedEvent | NotificationClosedEvent | NotificationCreatedEvent | NotificationsCountChanged | NotificationFormSubmittedEvent | NotificationReminderCreatedEvent | NotificationReminderRemovedEvent;
 export declare type TransportMappings<T> = T extends NotificationActionEvent ? NotificationActionEventTransport : never;
@@ -72,9 +71,6 @@ export declare type NotificationInternal<T extends NotificationOptions = Notific
     expires: number | null;
     _fragments?: (ActionableTextTemplateFragment | ImageTemplateFragment | ContainerTemplateFragment)[];
 };
-export interface NotificationPlatformInternal extends NotificationPlatform {
-    platformIdentity: OpenFin.ApplicationIdentity;
-}
 export declare type UpdatableNotificationInternal<T extends UpdatableNotificationOptions = UpdatableNotificationOptions> = UpdatableNotification<T> & {
     bodyText?: string;
     body?: string;
@@ -83,10 +79,6 @@ export interface ClearPayload {
     id: string;
 }
 export declare type ShowPayload = ShowOptions;
-export declare type PlatformRegisterPayload<T extends NotificationPlatform = NotificationPlatform> = T;
-export interface PlatformDeregisterPayload {
-    id: string;
-}
 export declare type ColorSchemeOption = 'light' | 'dark' | 'system';
 export interface NotificationActionEventTransport {
     type: 'notification-action';
@@ -102,3 +94,17 @@ export interface NotificationActionEventTransport {
  * https://davidgomes.com/pick-omit-over-union-types-in-typescript/
  */
 export declare type DistributiveOmit<T, K extends keyof T> = T extends unknown ? Omit<T, K> : never;
+/**
+ * Data returned by the service when registering a platform.
+ */
+export interface RegistrationMetaInfo {
+    /**
+     * Version of the client API.
+     */
+    clientAPIVersion: string;
+    /**
+     * Version of the notification service that is running.
+     * A response of 'unknown' indicates that an older version of the service is runningthat does not support returning the service version.
+     */
+    notificationsVersion: string;
+}

package/dist/client/log.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Internal helper class that logs output both to console (when inspecting app or window) and runtime's debug.log file.
+ */
+export declare class Log {
+    private static LOG_PREFIX;
+    static error(message: string): Promise<void>;
+    static warn(message: string): Promise<void>;
+    static info(message: string): Promise<void>;
+    private static getPrefixedMessage;
+    private static handleError;
+}

package/dist/client/log.spec.d.ts

@@ -0,0 +1 @@
+export {};