@openfin/web-notifications 2.9.1-alpha-3944

package/dist/web/index.d.ts

@@ -0,0 +1,1548 @@
+import OpenFin from '@openfin/core';
+
+/**
+ * Actions are the mechanism through which notifications send messages back to the application that created them. The
+ * service defines a number of ways in which actions can be raised (a notification being interacted with by the user,
+ * being closed, expiring, etc.), and it is up to each application to decide if it wishes to be informed when each of
+ * these triggers occur.
+ *
+ * For an action to be raised when one of these triggers occurs, the application must specify an
+ * {@link NotificationActionResult|action result} for each trigger it is interested in. The application should then
+ * listen for when these actions are raised by listening for the {@link NotificationActionEvent|`notification-action`}
+ * event.
+ *
+ * This event is fired once each time an action is raised, and will contain the
+ * {@link NotificationActionResult|action result} the application specified for that trigger. The application may then
+ * use the {@link NotificationActionResult|action result} to determine which trigger occurred and respond appropriately.
+ *
+ * If an {@link NotificationActionResult|action result} is not specified for a particular trigger, or it is set to
+ * `null`, the application will not receive a corresponding {@link NotificationActionEvent|`notification-action`} when
+ * that trigger occurs.
+ *
+ * Unlike other event types, {@link NotificationActionEvent|`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
+ * {@link NotificationActionEvent|`notification-action`} events. The service will also attempt to restart the
+ * application if it is not running when the event is fired.
+ *
+ * For an overview of actions, consider the sample notification below:
+ * ```ts
+ * import {addEventListener, create} from 'openfin-notifications';
+ *
+ * // Create a notification with two buttons
+ * create({
+ *     // Basic info
+ *     title: 'Reminder',
+ *     body: 'Event "Weekly Meeting" is starting soon...',
+ *
+ *     // We'll use the 'customData' field to store metadata about the event
+ *     customData: {eventId: '12345'},
+ *
+ *     // We want the user clicking the notification to open the associated event, so register an 'onSelect' action
+ *     onSelect: {task: 'view-calendar-event', target: 'popup'},
+ *
+ *     buttons: [
+ *         // A button that will schedule another reminder for 5 minutes from now. Since the application will be
+ *         // responsible for snoozing the event, it will need to know about the user clicking this button. By setting
+ *         // a NotificationActionResult for 'onClick', the service will raise a "notification-action" event when this
+ *         // button is clicked, and will pass the value of 'onClick' as the 'result' field within the event
+ *         {
+ *             title: 'Snooze for 5 minutes',
+ *             iconUrl: 'https://www.example.com/timer.png',
+ *             onClick: {
+ *                 task: 'schedule-reminder',
+ *                 intervalMs: 5 * 60 * 1000
+ *             }
+ *         },
+ *
+ *         // A button that closes the notification and doesn't prompt the user about this event again. Since the
+ *         // application doesn't need to do anything when the user clicks this button, we leave 'onClick' undefined
+ *         // rather than specifying a NotificationActionResult. This means that no action will be raised when the
+ *         // button is clicked, and hence no "notification-action" event will be fired
+ *         {
+ *             title: 'Dismiss',
+ *             iconUrl: 'https://www.example.com/cancel.png'
+ *         }
+ *     ]
+ * });
+ *
+ * // Create a listener that will be called for each action
+ * // Note: This handler will be used for ALL actions, from ALL notifications that are created by this application.
+ * addEventListener('notification-action', (event: NotificationActionEvent) => {
+ *     const {result, notification} = event;
+ *
+ *     if (result['task'] === 'view-calendar-event') {
+ *         // Open a window with full details of the associated event
+ *         openEventDetails(notification.customData.eventId, result['target']);
+ *     } else if (result['task'] === 'schedule-reminder') {
+ *         // Schedule a new notification
+ *         scheduleReminder(notification.customData.eventId, Date.now() + result['intervalMs']);
+ *     } // Etc...
+ * });
+ * ```
+ *
+ * The example above uses `customData` to store details about the notification subject (in this case, a calendar
+ * event), and `onClick` actions to inform the application about how it should respond when the user interacts with the
+ * notification. This is our intended usage and recommended best-practice, but the service doesn't require applications
+ * to follow this convention - application developers are free to decide how to manage notification state.
+ *
+ * Within the `notification-action` handler, the application must be able to understand which notification is being
+ * handled, and how to decide what it should do next. The example above uses an application-defined `action` field to
+ * determine the correct action, but the notification's `id`, `customData` and other fields are also useful
+ * selectors.
+ *
+ * @module Actions
+ */
+/**
+ * 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
+ */
+
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * The `NotificationActionResult returned back to an application is static
+ * and must be defined at the point where the notification is created.
+ */
+type ActionDeclaration<T extends never, E extends never> = NotificationActionResult;
+/**
+ * Data type used to represent the action result returned back to applications when an action is raised. Applications
+ * capture these responses by adding a `notification-action` listener. The contents of this type are entirely
+ * application-defined, the only requirement is that the item is serializable by `JSON.stringify`.
+ *
+ * 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 propagated up to {@link NotificationActionEvent}.
+ * The example below demonstrates this, using the same use-case as at the top of this page.
+ *
+ * ```ts
+ * interface MyAction = SnoozeAction | DetailsAction;
+ *
+ * interface SnoozeAction {
+ *     task: 'schedule-reminder';
+ *     intervalMs: number;
+ * }
+ *
+ * interface DetailsAction {
+ *     task: 'view-calendar-event';
+ *     target: 'self'|'popup';
+ * }
+ *
+ * addEventListener('notification-action', (event: NotificationActionEvent<MyAction>)) => {
+ *     if (event.result.task === 'schedule-reminder') {
+ *         // 'event.result' will now be strongly-typed as an instance of SnoozeAction
+ *         scheduleReminder(notification.customData.eventId, Date.now() + result.intervalMs);
+ *     }
+ *     // Etc...
+ * };
+ * ```
+ */
+type NotificationActionResult<T = CustomData> = T;
+/**
+ * Noop action types see {@link ActionNoop|ActionNoop}.
+ */
+declare enum ActionNoopType {
+    /**
+     * No event will be raised and no dismissal of the notification on action.
+     */
+    EVENT_DISMISS = "event_dismiss"
+}
+/**
+ * BODY_CLICK action types see {@link ActionBodyClick|ActionBodyClick}.
+ */
+declare enum ActionBodyClickType {
+    /**
+     * Dissmisal/Clearing event will be raised
+     */
+    DISMISS_EVENT = "dismiss_event"
+}
+/**
+ * @depracated {__NOOP__} has been deprecated. Notifications now default to not triggering the dismiss action when the body is clicked
+ *
+ * Setting the `__NOOP__` field on an action with a {@link ActionNoopType|type} allows you to override default user interaction with a notification.
+ *
+ * @example
+ * ```
+ * const notification = {
+ *  //...
+ *  onSelect: {__NOOP__: ActionNoopType.EVENT_DISMISS}
+ * };
+ * ```
+ *
+ * When a user clicks the notification body, the notification will not be dismissed and no event will be raised to the client application.
+ *
+ * <li> Currently <code>ActionBodyClickType.DISMISS_EVENT</code> is only supported by <code>ActionTrigger.SELECT/onSelect</code></li>
+ */
+interface ActionNoop {
+    __NOOP__?: ActionNoopType;
+}
+/**
+ * Set the `BODY_CLICK` field on an action with a {@link ActionBodyClickType|type} to allow the end-user to click the body of the notification to dismiss it. This was the default behavior in earlier releases. An event is also sent to the client application.
+ *
+ * Note the following restrictions:
+ *
+ * <ul>
+ *   <li>This override is ignored if buttons are passed to notification options.</li>
+ *   <li>The <code>ActionBodyClickType.DISMISS_EVENT</code> is supported only by <code>ActionTrigger.SELECT/onSelect</code></li>
+ *
+ * @example
+ * ```
+ * const notification = {
+ *  //...
+ *  onSelect: {BODY_CLICK: ActionBodyClickType.DISMISS_EVENT}
+ * };
+ * ```
+ *
+ */
+interface ActionBodyClick {
+    BODY_CLICK?: ActionBodyClickType;
+}
+
+/**
+ * @module Notifications
+ */
+/**
+ * @deprecated
+ * Lists possible semantic use-cases for notifications, which can alter how the notification is presented to the user.
+ */
+declare enum IndicatorType {
+    FAILURE = "failure",
+    WARNING = "warning",
+    SUCCESS = "success"
+}
+/**
+ * Lists possible colors available for use as NotificationIndicator background color.
+ */
+declare enum IndicatorColor {
+    RED = "red",
+    GREEN = "green",
+    YELLOW = "yellow",
+    BLUE = "blue",
+    PURPLE = "purple",
+    GRAY = "gray",
+    ORANGE = "orange",
+    MAGENTA = "magenta",
+    TEAL = "teal"
+}
+interface NotificationIndicator {
+    /**
+     * @deprecated
+     *
+     * Deprecated - use the priority field instead.
+     *
+     * Indicates the semantic intent behind the indicator - this determines the visual styling of the indicator when
+     * seen by the user.
+     *
+     * For example - an indicator could be used to:
+     * - `IndicatorType.FAILURE`: Indicate a failure has occurred from an action the user has taken.
+     * - `IndicatorType.WARNING`: Warn a user that they have a limited amount of time to buy.
+     * - `IndicatorType.SUCCESS`: Inform the user that an item has been successfully ordered.
+     */
+    type?: IndicatorType;
+    /**
+     * The indicator banner color. Defaults to red.
+     */
+    color?: IndicatorColor;
+    /**
+     * Customized text to be displayed in the indicator. When set, this will override the default indicator text.
+     * Text is limited to 32 characters including spaces.
+     */
+    text?: string;
+}
+interface NotificationIndicatorWithCustomColor extends Omit<NotificationIndicator, 'color'> {
+    /**
+     * Custom color string for indicator banner. This string must be defined in `theme` during Workspace Platform initialization.
+     */
+    color: string;
+    /**
+     * Fallback color if custom color could not be found in theme.
+     */
+    fallback: IndicatorColor;
+}
+
+declare const WidgetType: {
+    readonly Time: "Time";
+    readonly Date: "Date";
+    readonly RadioGroup: "RadioGroup";
+    readonly CheckboxGroup: "CheckboxGroup";
+    readonly Toggle: "Toggle";
+    readonly Checkbox: "Checkbox";
+    readonly Number: "Number";
+    readonly Text: "Text";
+    readonly Dropdown: "Dropdown";
+};
+interface BaseWidgetSpec<T extends keyof typeof WidgetType> {
+    /**
+     * The type of widget to be used. Widgets can only be used with matching specific data types.
+     * For example the `Text` widget can be used with the `string` field type.
+     */
+    type: T;
+}
+/**
+ * A simple text field input widget.
+ */
+interface TextWidgetSpec extends BaseWidgetSpec<typeof WidgetType['Text']> {
+    placeholder?: string;
+    multiline?: boolean;
+    rows?: number;
+}
+/**
+ * String field input widget.
+ */
+type StringWidget = TextWidgetSpec | DropdownWidgetSpec;
+interface NumberWidgetSpec extends BaseWidgetSpec<typeof WidgetType['Number']> {
+    placeholder?: string;
+    min?: number;
+    max?: number;
+    currencyChar?: string;
+    decimalPlaces?: number;
+    step?: number;
+}
+interface CheckboxGroupWidgetSpec extends BaseWidgetSpec<typeof WidgetType['CheckboxGroup']> {
+    group: Array<{
+        value: string;
+        label: string;
+    }>;
+}
+type CheckboxGroupWidget = CheckboxGroupWidgetSpec;
+interface RadioGroupWidgetSpec extends BaseWidgetSpec<typeof WidgetType['RadioGroup']> {
+    group: Array<{
+        value: string;
+        label: string;
+    }>;
+}
+type RadioGroupWidget = RadioGroupWidgetSpec;
+interface DateWidgetSpec extends BaseWidgetSpec<typeof WidgetType['Date']> {
+    minDate?: Date | null;
+    maxDate?: Date | null;
+}
+type TimeWidgetSpec = BaseWidgetSpec<typeof WidgetType['Time']>;
+type DateWidget = DateWidgetSpec;
+type TimeWidget = TimeWidgetSpec;
+interface DropdownWidgetSpec extends BaseWidgetSpec<typeof WidgetType['Dropdown']> {
+    placeholder?: string;
+    options: Array<{
+        value: string;
+        label: string;
+    }>;
+}
+/**
+ * Number field input widget.
+ */
+type NumberWidget = NumberWidgetSpec;
+type ToggleWidgetSpec = BaseWidgetSpec<typeof WidgetType['Toggle']>;
+type CheckboxWidgetSpec = BaseWidgetSpec<typeof WidgetType['Checkbox']>;
+type BooleanWidget = ToggleWidgetSpec | CheckboxWidgetSpec;
+
+/**
+ * @hidden
+ */
+/**
+ * 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
+ */
+/**
+ * For notifications that have originated from an application running on the same machine as the provider.
+ */
+interface NotificationSourceDesktop {
+    type: 'desktop';
+    /**
+     * The identity of the window that raised this notification.
+     *
+     * This will always be a window of the current application - but
+     * could have been raised by an instance of this application
+     * running on a different machine.
+     */
+    identity: OpenFin.Identity;
+    /**
+     * The origin of the notification, which is the url of the window that raised the notification.
+     * This property is optional to support backward compatibility with sources that do not have the origin starting with version 2.7.1.
+     */
+    origin?: string;
+}
+/**
+ * Union of all possible notification sources.
+ */
+type NotificationSource = NotificationSourceDesktop;
+
+/**
+ * A rule that specifies the allowed origins that can access
+ * the stored notification data and update the notifications
+ */
+interface NotificationSecurityRule {
+    /**
+     * Array of [match patterns](https://developer.chrome.com/docs/extensions/develop/concepts/match-patterns)
+     * specifying the allowed origins that can access to the notification(s) for the client.
+     * If an empty array is provided, then no origins are allowed to access the stored notifications for the client.
+     */
+    allowedOrigins: string[];
+}
+
+/**
+ * @hidden
+ */
+/**
+ * File contains types used to communicate between client and provider.
+ *
+ * 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.
+ */
+
+type NotificationInternal<T extends NotificationOptions = NotificationOptions> = DistributiveOmit<Notification<T>, 'date' | 'expires'> & {
+    date: number;
+    expires: number | null;
+    _fragments?: (ActionableTextTemplateFragment | ImageTemplateFragment | ContainerTemplateFragment)[];
+};
+/**
+ * Distribute Omit across all union types instead of Omitting the union.
+ * https://davidgomes.com/pick-omit-over-union-types-in-typescript/
+ */
+type DistributiveOmit<T, K extends keyof T> = T extends unknown ? Omit<T, K> : never;
+type MakePropertyRequired<T, Prop extends keyof T> = Omit<T, Prop> & Required<Pick<T, Prop>>;
+
+/**
+ * When you make a form, you provide a list of [[FormFields]]. Each FormField contains the ingredients to make a single widget in the form.
+ * The actual definitions of the widgets are derived from [[BaseWidgetSpec]].
+ *
+ * A FormField contains the type of data, the key to store the user input into [[CustomDataWithForms]], and some additional configuration.
+ * @module FormFields
+ */
+/**
+ * imports.
+ */
+
+/**
+ * Data type of a fields. e.g. string, number
+ */
+declare const FieldType: {
+    readonly string: "string";
+    readonly number: "number";
+    readonly boolean: "boolean";
+    readonly date: "date";
+    readonly checkboxGroup: "checkboxGroup";
+    readonly radioGroup: "radioGroup";
+    readonly time: "time";
+};
+/**
+ * An abstract validation entry.
+ */
+interface ValidationEntry<T = any> {
+    /**
+     * Message displayed to the user when input is invalid.
+     */
+    invalidMessage?: string;
+    /**
+     * Validation argument to test against.
+     */
+    arg?: T;
+}
+/**
+ * The base type for form fields.
+ */
+interface BaseField<T extends keyof typeof FieldType, D = unknown> {
+    /**
+     * Field data type.
+     */
+    type: T;
+    /**
+     * The property key that this field value will appear in the returned {@link NotificationFormSubmittedEvent.form|form} object.
+     */
+    key: string;
+    /**
+     * Default value for field, and where it will be written to
+     */
+    value?: D;
+    /**
+     * Validation rules used to validate user input.
+     */
+    validation?: Record<string, any>;
+    /**
+     * Input label.
+     */
+    label?: string;
+    /**
+     * Helper text.
+     */
+    helperText?: string;
+}
+/**
+ * String field within a form.
+ */
+interface StringField<W extends StringWidget = StringWidget> extends BaseField<'string', string> {
+    validation?: Partial<{
+        /**
+         * Minimum number of characters.
+         */
+        min: ValidationEntry<number>;
+        /**
+         * Maximum number of characters.
+         */
+        max: ValidationEntry<number>;
+        /**
+         * Length of the input string.
+         */
+        length: ValidationEntry<number>;
+        /**
+         * The field is required to be filled in by the user.
+         */
+        required: ValidationEntry;
+        /**
+         * Provide a regex string that will be tested against the input value.
+         */
+        match: ValidationEntry<string>;
+    }>;
+    /**
+     * What input widget is used.
+     * @default StringWidgets {@link StringWidgets}
+     */
+    widget: W;
+}
+/**
+ * Number field within a form.
+ */
+interface NumberField<W extends NumberWidget = NumberWidget> extends BaseField<'number', number> {
+    validation?: Partial<{
+        /**
+         * Minimum number of characters.
+         */
+        min: ValidationEntry<number>;
+        /**
+         * Maximum number of characters.
+         */
+        max: ValidationEntry<number>;
+        /**
+         * Number must be less than this.
+         */
+        lessThan: ValidationEntry<number>;
+        /**
+         * Number must be more than this.
+         */
+        moreThan: ValidationEntry<number>;
+        /**
+         * Number must be positive.
+         */
+        positive: ValidationEntry;
+        /**
+         * Number must be negative.
+         */
+        negative: ValidationEntry;
+        /**
+         * The field is required to be filled in by the user.
+         */
+        required: ValidationEntry;
+    }>;
+    widget: W;
+}
+interface BooleanField<W extends BooleanWidget = BooleanWidget> extends BaseField<'boolean', boolean> {
+    widget: W;
+}
+type DateFieldValue = {
+    date?: number;
+    month?: number;
+    year?: number;
+};
+interface DateField<W extends DateWidget = DateWidget> extends BaseField<'date', DateFieldValue> {
+    widget: W;
+}
+type TimeFieldValue = {
+    hour?: number;
+    minute?: number;
+};
+interface TimeField<W extends TimeWidget = TimeWidget> extends BaseField<'time', TimeFieldValue> {
+    widget: W;
+}
+interface RadioGroupField<W extends RadioGroupWidget = RadioGroupWidget> extends BaseField<'radioGroup', string> {
+    widget: W;
+}
+interface CheckboxGroupField<W extends CheckboxGroupWidget = CheckboxGroupWidget> extends BaseField<'checkboxGroup', Array<string>> {
+    widget: W;
+}
+/**
+ * A field in a form.
+ */
+type FormField = StringField | NumberField | BooleanField | DateField | RadioGroupField | CheckboxGroupField | TimeField;
+/**
+ * A field in a form.
+ *
+ * The difference with [[FormField]] is that the label property is required.
+ */
+type FormFieldWithRequiredLabel = MakePropertyRequired<FormField, 'label'>;
+/**
+ * An ordered array of fields representing a form.
+ * When the form is displayed to the user the fields will appear in the same order they are in the array.
+ */
+type NotificationFormData = ReadonlyArray<FormField>;
+/**
+ * An ordered array of fields representing a form.
+ * When the form is displayed to the user the fields will appear in the same order they are in the array.
+ *
+ * The difference with [[NotificationFormData]] is that the label property is required for each field.
+ */
+type NotificationFormDataWithRequiredLabel = ReadonlyArray<FormFieldWithRequiredLabel>;
+
+/**
+ * OpenFin Notification Templates API Version 1
+ *
+ * @module Templates
+ */
+/**
+ * imports
+ */
+
+type SectionAlignment = 'left' | 'center' | 'right';
+type ListPairs = [string, string][];
+type CustomTemplateData = Record<string, string | ListPairs>;
+/**
+ * The options you pass to the [[create]] function to generate a notification.
+ */
+type NotificationOptions = TemplateMarkdown | TemplateList | TemplateCustom;
+/**
+ * The options to build your custom template composition layout.
+ */
+type TemplateFragment = ContainerTemplateFragment | TextTemplateFragment | ListTemplateFragment | ImageTemplateFragment | ActionableTextTemplateFragment;
+declare const TemplateNames: {
+    readonly markdown: "markdown";
+    readonly list: "list";
+    readonly custom: "custom";
+};
+declare const PresentationTemplateFragmentNames: {
+    readonly text: "text";
+    readonly image: "image";
+    readonly list: "list";
+    readonly actionableText: "actionableText";
+};
+declare const TemplateFragmentNames: {
+    readonly text: "text";
+    readonly image: "image";
+    readonly list: "list";
+    readonly actionableText: "actionableText";
+    readonly container: "container";
+};
+interface TemplateComposition {
+    /**
+     * Minimum Template API version required for the service to render this composition.
+     *
+     * For example, a composition that consists only of container, text, image, or list
+     * fragments must declare a minimum template API version of "1".
+     *
+     * See {@link BodyTemplateOptions} for more details.
+     */
+    minTemplateAPIVersion: string;
+    /**
+     * Root of the template composition tree. See {@link ContainerTemplateFragment} for nesting.
+     */
+    layout: TemplateFragment;
+}
+interface IndicatorTemplateOptions {
+    /**
+     * Alignment of the notification's indicator section.
+     *
+     * Can be `left`, `center` or `right`.
+     *
+     * The default value is `center`.
+     */
+    align?: SectionAlignment;
+    /**
+     * Color of the indicator bar.
+     *
+     * Note: {@link BaseNotificationOptions|Notification's indicator color} definition has precedence over Template definition.
+     * Template's indicator color value will be taken into account only if the notification itself doesn't have the indicator color
+     * specified.
+     */
+    color?: IndicatorColor;
+}
+interface ButtonTemplateOptions {
+    /**
+     * Alignment of the notification's button section.
+     *
+     * Can be `left`, `center` or `right`.
+     *
+     * The default value is `right`.
+     */
+    align?: SectionAlignment;
+}
+interface BodyTemplateOptions {
+    /**
+     * A list of template compositions.
+     *
+     * You can include multiple compositions with different minimum Template API version to create fallback compositions and support the
+     * earlier versions of Notification Center (Starting from the Template API version 1).
+     *
+     * The service will search for the composition with the version number matching the Template API version it is supporting.
+     * If this doesn't exist, the service will then select the composition with the nearest version number smaller than the Template API version
+     * it is supporting and render the notification card with that composition.
+     */
+    compositions: TemplateComposition[];
+    /**
+     * Composition fallback text.
+     *
+     * The service will render this text instead of the notification body section if there are no compatible compositions found in the template.
+     *
+     * (E.g. All of the compositions in the template declare a greater minimum Template API version than the version supported by the running
+     *  service instance.)
+     *
+     */
+    fallbackText?: string;
+}
+interface BaseTemplateFragment<T extends keyof typeof TemplateFragmentNames> {
+    /**
+     * Type of the template fragment.
+     */
+    type: T;
+    /**
+     * CSS style properties of the fragment.
+     *
+     * All the available custom template fragments support all of the React's inline style properties (with camelCase keys)
+     *
+     * Note: "position: fixed" is disallowed in the fragments.
+     */
+    style?: Record<string, string | number>;
+}
+interface ContainerTemplateFragment extends BaseTemplateFragment<'container'>, ActionableFragment {
+    /**
+     * Sub-fragments of the container.
+     *
+     * You can use container template fragment to create nested composition structures.
+     */
+    children?: TemplateFragment[];
+}
+interface PresentationTemplateFragment<T extends keyof typeof PresentationTemplateFragmentNames> extends BaseTemplateFragment<T> {
+    /**
+     * Optional flag.
+     *
+     * If a presentation template fragment is flagged as optional, The service will not require
+     * the fragment's `dataKey` to exist in `templateData`. If a fragment is optional and its data
+     * is missing, the fragment will be omitted quietly by the server.
+     */
+    optional?: boolean;
+    /**
+     * Data key of the template fragment.
+     *
+     * The data associated with this fragment will be looked up in `templateData` map with this key.
+     *
+     * Example:
+     * ```ts
+     * const myTemplate = {
+     *   body: {
+     *     compositions: [{
+     *       minTemplateAPIVersion: '1',
+     *       layout: {
+     *         type: CustomTemplateFragmentNames.text,
+     *         dataKey: 'message',
+     *       },
+     *     }],
+     *   },
+     * }
+     *
+     * const notificationOption: TemplateCustom = {
+     *   //...
+     *   templateOptions: myTemplate,
+     *   templateData: {
+     *     message: 'My Custom Notification Message',
+     *   }
+     * };
+     * ```
+     *
+     */
+    dataKey: string;
+}
+interface ActionableFragment {
+    /**
+     * onClick object that is user defined.
+     *
+     * If provided, notification-action event will be raised when clicking on the fragment.
+     *
+     *
+     * Example:
+     * ```ts
+     * {
+     *  "type": "actionableText",
+     *  "dataKey": "titlexyz",
+     *  "tooltipKey": "some_key",
+     *  "onClick": { // contents are user-defined
+     *    "task": "schedule-reminder",
+     *    "eventId": 142341,
+     *    "intervalMs": 5000
+     *  }
+     * }
+     *
+     * import { addEventListener, clear } from 'openfin-notifications';
+     *
+     * addEventListener('notification-action', (event: NotificationActionEvent<MyAction>)) => {
+     *  if (event.result.task === 'schedule-reminder') {
+     *    scheduleReminder(event.result.eventId, Date.now() + event.result.intervalMs);
+     *  }
+     *  clear(event.notification.id);
+     * });
+     * ```
+     *
+     */
+    onClick?: ActionDeclaration<never, never> | null;
+    /**
+     * Tooltip key of the template fragment.
+     *
+     * The string tooltip associated with this fragment will be looked up in templateData map with this key.
+     *
+     *
+     * Example:
+     * ```ts
+     * const myTemplate = {
+     *   body: {
+     *     compositions: [{
+     *       minTemplateAPIVersion: '1',
+     *       layout: {
+     *         type: "actionableText",
+     *         dataKey: 'message',
+     *         tooltipKey: 'tooltipxyz',
+     *       },
+     *     }],
+     *   },
+     * }
+     *
+     * const notificationOption: TemplateCustom = {
+     *   //...
+     *   templateOptions: myTemplate,
+     *   templateData: {
+     *     message: 'view stock tracker',
+     *     tooltipxyz: 'My Custom Tooltip',
+     *   }
+     * };
+     * ```
+     *
+     */
+    tooltipKey?: string;
+}
+type TextTemplateFragment = PresentationTemplateFragment<'text'>;
+type ImageTemplateFragment = PresentationTemplateFragment<'image'> & ActionableFragment;
+type ListTemplateFragment = PresentationTemplateFragment<'list'>;
+type ActionableTextTemplateFragment = PresentationTemplateFragment<'actionableText'> & ActionableFragment;
+/**
+ * Configuration options for the custom notification template.
+ */
+interface CustomTemplateOptions {
+    /**
+     * Configuration options for the custom notification template body.
+     */
+    body: BodyTemplateOptions;
+    /**
+     * Configuration options for the custom notification template's modifications on the notification's indicator section.
+     */
+    indicator?: IndicatorTemplateOptions;
+    /**
+     * Configuration options for the custom notification template's modifications on the notification's button section.
+     */
+    buttons?: ButtonTemplateOptions;
+}
+/**
+ * Default markdown template. Contains a markdown body and forms data.
+ */
+interface TemplateMarkdown extends Omit<BaseNotificationOptions<'markdown'>, 'template'> {
+    template?: 'markdown';
+    /**
+     * Notification body text.
+     *
+     * This is the main notification content, displayed below the notification title. The notification will expand to fit the length of this text.
+     * Markdown may be used in the body text to control how it is styled when rendered.
+     * With the exception of links and code blocks, all basic syntax as documented [here](https://www.markdownguide.org/basic-syntax) is supported.
+     */
+    body: string;
+    /**
+     * A collection of form fields or a form definition (Form<FormField>)
+     * @example
+     * ```ts
+     *  [
+     *    {
+     *      key: 'phone',
+     *      type: 'string',
+     *      label: 'Phone',
+     *      helperText:
+     *        'Must be in the following formats 123-456-7890, 123 456 7890, (123) 456 7890 or 1234567890',
+     *      widget: {
+     *        type: 'Text'
+     *      },
+     *      validation: {
+     *        required: {
+     *          arg: true
+     *        }
+     *      }
+     *    },
+     *    {
+     *      key: 'email',
+     *      type: 'string',
+     *      label: 'Email',
+     *      helperText: 'We will use this email to send you the report after we crawl your website',
+     *      widget: {
+     *        type: 'Text'
+     *      },
+     *      validation: {
+     *        required: {
+     *          arg: true
+     *        }
+     *      }
+     *    }
+     *  ]
+     *  ```
+     */
+    form?: NotificationFormData | Form<FormField> | null;
+}
+/**
+ * Simple template that can render a list of name-value pairs.
+ */
+interface TemplateList extends BaseNotificationOptions<'list'> {
+    /**
+     * Notification list template data.
+     */
+    list: Record<string, string>;
+}
+/**
+ * Notification that renders custom templates.
+ */
+interface TemplateCustom extends BaseNotificationOptions<'custom'> {
+    templateOptions: CustomTemplateOptions;
+    /**
+     * Data associated with the custom notification template's presentation fragments.
+     */
+    templateData: CustomTemplateData;
+    /**
+     * A collection of form fields or a form definition (Form<FormField>)
+     * @example
+     * ```ts
+     *  [
+     *    {
+     *      key: 'phone',
+     *      type: 'string',
+     *      label: 'Phone',
+     *      helperText:
+     *        'Must be in the following formats 123-456-7890, 123 456 7890, (123) 456 7890 or 1234567890',
+     *      widget: {
+     *        type: 'Text'
+     *      },
+     *      validation: {
+     *        required: {
+     *          arg: true
+     *        }
+     *      }
+     *    },
+     *    {
+     *      key: 'email',
+     *      type: 'string',
+     *      label: 'Email',
+     *      helperText: 'We will use this email to send you the report after we crawl your website',
+     *      widget: {
+     *        type: 'Text'
+     *      },
+     *      validation: {
+     *        required: {
+     *          arg: true
+     *        }
+     *      }
+     *    }
+     *  ]
+     *  ```
+     */
+    form?: NotificationFormDataWithRequiredLabel | Form<FormFieldWithRequiredLabel> | null;
+}
+interface FormSettings {
+    /**
+     * Controls that display of (Required) or (Optional) labels next to form fields.
+     */
+    displayFieldRequirementStatus?: boolean;
+}
+interface Form<T extends FormField | FormFieldWithRequiredLabel> extends FormSettings {
+    /**
+     * A collection of form fields.
+     * @example
+     * ```ts
+     *  [
+     *    {
+     *      key: 'phone',
+     *      type: 'string',
+     *      label: 'Phone',
+     *      helperText:
+     *        'Must be in the following formats 123-456-7890, 123 456 7890, (123) 456 7890 or 1234567890',
+     *      widget: {
+     *        type: 'Text'
+     *      },
+     *      validation: {
+     *        required: {
+     *          arg: true
+     *        }
+     *      }
+     *    },
+     *    {
+     *      key: 'email',
+     *      type: 'string',
+     *      label: 'Email',
+     *      helperText: 'We will use this email to send you the report after we crawl your website',
+     *      widget: {
+     *        type: 'Text'
+     *      },
+     *      validation: {
+     *        required: {
+     *          arg: true
+     *        }
+     *      }
+     *    }
+     *  ]
+     *  ```
+     */
+    fields: ReadonlyArray<T>;
+}
+
+/**
+ * Core notification features.
+ *
+ * @module BaseNotificationOptions
+ */
+/**
+ * imports
+ */
+
+/**
+ * Configuration options for constructing a Notifications object, shared between all templates.
+ */
+interface BaseNotificationOptions<T extends keyof typeof TemplateNames> {
+    /**
+     * A unique identifier for the notification.
+     *
+     * If not provided at time of creation, one will be generated for you and returned as part of the {@link create} method.
+     */
+    id?: string;
+    /**
+     * Template of the notification payload.
+     */
+    template: T;
+    /**
+     * Title of the notification.
+     *
+     * Displayed as the first line of the notification, in a heading style.
+     */
+    title: string;
+    /**
+     * If set to false, the user won't be able to set a reminder for this notification in the Notification Center.
+     *
+     * Default value is `true`.
+     */
+    allowReminder?: boolean;
+    /**
+     * Describes the context of this notification. Allows users to control different notification types that are raised
+     * by an application.
+     *
+     * This string is not displayed on the notification itself, but should be user-readable. It will be displayed in
+     * the Notification Center preferences section, and any string passed as a `category` should make sense when
+     * displayed in that context.
+     *
+     * Event categories should list all the different types of notifications raised by your app. As a general guide, if
+     * a user may want to have different preferences for some subset of notifications created by your app, then
+     * applications should ensure that those notifications have a distinct category.
+     *
+     * @deprecated This property is deprecated and will be removed in a future release.
+     */
+    category?: string;
+    /**
+     * Add a semantic visual indicator to a notification, to signal to the user the nature of the event that they are
+     * being notified about.
+     *
+     * This should not be treated as a priority.
+     */
+    indicator?: NotificationIndicator | NotificationIndicatorWithCustomColor | null;
+    /**
+     * URL of the icon to be displayed in the notification.
+     */
+    icon?: string;
+    /**
+     * Application-defined context data that can be attached to buttons on notifications.
+     *
+     * When using forms, form data submitted will be written to `customData` and returned to your app by
+     * listening to the submit {@link NotificationActionEvent|`notification-action`} with the trigger {@link ActionTrigger.SUBMIT|submit}.
+     */
+    customData?: CustomData;
+    /**
+     * The timestamp shown on the notification. If omitted, the current date/time will be used.
+     *
+     * This is presentational only - a date in the future does not incur a scheduling action.
+     */
+    date?: Date;
+    /**
+     * The expiry date and time of the notification. If specified, the notification will be removed at this time, or as
+     * soon as possible after. If not specified, the notification will never expire, and will persist until it
+     * is closed.
+     */
+    expires?: Date | null;
+    /**
+     * When set to `sticky` this settings enables the notification toast to stay visible on the desktop
+     * until the user interacts with it. When set to `transient` the toasts will follow the default behavior
+     * of fading away after a short duration. When set to `none` the toasts will not appear and the notification
+     * will only appear in the Notification Center.
+     *
+     * This property has a precedence over `sticky` propery.
+     *
+     */
+    toast?: 'sticky' | 'transient' | 'none';
+    /**
+     * @deprecated
+     *
+     * This property is deprecated. Use `toast` instead.
+     */
+    sticky?: 'sticky' | 'transient';
+    /**
+     * A list of buttons to display below the notification text.
+     *
+     * Notifications support up to four buttons. Attempting to add more than four will result in the notification
+     * being rejected by the service.
+     */
+    buttons?: ButtonOptions[];
+    /**
+     * Notification Stream
+     *
+     * If the notification belongs to a stream, the user  will be able to group notifications by stream.
+     */
+    stream?: NotificationStream | null;
+    /**
+     * Id of the platform this notification belongs to.
+     *
+     * If the application belongs to a platform, the user interaction with the notification will be dispatched
+     * back to the platform provider.
+     */
+    platform?: string | null;
+    /**
+     * An {@link NotificationActionResult|action result} to be passed back to the application inside the
+     * {@link NotificationActionEvent|`notification-action`} event fired when the notification is clicked.
+     *
+     * This action will only be raised on clicks to the notification body. Interactions with buttons (both
+     * application-defined buttons, and the default 'X' close button) or with actionable fragments will not trigger a
+     * {@link ActionTrigger.SELECT|select} action.
+     *
+     * See {@link Actions} for more details on notification actions, and receiving action events from notifications.
+     */
+    onSelect?: (ActionDeclaration<never, never> & ActionNoop & ActionBodyClick) | null;
+    /**
+     * An {@link NotificationActionResult|action result} to be passed back to the application inside the
+     * {@link NotificationActionEvent|`notification-action`} event fired when the notification the expires.
+     *
+     * If `expires` is specified for the notification, this action will be raised when the notification expires. If
+     * `expires` is not specified for the notification, this action will never be raised. Note that if an `onClose`
+     * action result is also specified, both actions will be raised if and when the notification expires.
+     *
+     * See {@link Actions} for more details on notification actions, and receiving action events from notifications.
+     */
+    onExpire?: ActionDeclaration<never, never> | null;
+    /**
+     * An {@link NotificationActionResult|action result} to be passed back to the application inside the
+     * {@link NotificationActionEvent|`notification-action`} event fired when the notification is closed.
+     *
+     * This action is raised regardless of how the notification is closed, whether from user interaction, expiration,
+     * or programmatic removal -- such as a call to `clear`.
+     *
+     * See {@link Actions} for more details on notification actions, and receiving action events from notifications.
+     */
+    onClose?: ActionDeclaration<never, never> | null;
+    /**
+     * A priority for this notification. It's from 1 - 4.
+     */
+    priority?: number;
+    /**
+     * Sound options for a notification.
+     */
+    soundOptions?: NotificationSoundOptions;
+}
+
+/**
+ * Notifications allow additional UI components to be specified by applications. The service controls the
+ * positioning and styling of these components.
+ *
+ * @module Controls
+ */
+/**
+ * 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
+ */
+
+/**
+ * Configuration options for constructing a button within a notification.
+ */
+interface ButtonOptions {
+    /**
+     * The type of the control. Optional, added automatically if `NotificationOptions.buttons` includes the `onClick`
+     * property and therefore generates a `notification-action` event.
+     */
+    type?: 'button';
+    /**
+     * User-facing button text.
+     *
+     * The button caption should be kept short, particularly if there are multiple buttons. Notifications are
+     * fixed-width, and all buttons will be displayed on the same row.
+     */
+    title: string;
+    /**
+     * Indicates that this button will be visually displayed as a 'Call to Action' button. In this case a Call To Action
+     * means the button is made more prominent. We recommend you use this for true calls to action. For example, if you
+     * have a notification which contains a report, it might have an 'OK' button which takes you to the report, and a
+     * 'Dismiss' button which simply closes the notification. We suggest you make only the 'OK' button a CTA here.'
+     *
+     * If set as `false` or `undefined`, the default simple text button will be used instead.
+     */
+    cta?: boolean;
+    /**
+     * Indicates that this button should submit a form.
+     * If a form is invalid, based on your validation rules provided, the button will be disabled until the users input within the form is valid.
+     */
+    submit?: boolean;
+    /**
+     * @deprecated
+     * Optional icon URL, if an icon should be placed on the button.
+     *
+     * Icons are placed to the left of the button text.
+     */
+    iconUrl?: string;
+    /**
+     * Defines the data to be passed back to the application when the button is clicked.
+     *
+     * The {@link NotificationActionResult} specified here will be returned to the application via a
+     * `notification-action` event when the button is clicked.
+     *
+     * If omitted or `null`, applications will not receive a {@link NotificationActionEvent|`notification-action`}
+     * event when the button is clicked. This may be appropriate if the button represents a "dismiss" or some other
+     * side-effect-free interaction. Even if `onClick` is omitted or `null`, a `notification-closed` event will still be
+     * raised after the button click.
+     *
+     */
+    onClick?: ActionDeclaration<never, never> | null;
+    /**
+     * Button index used for events. This gets set when hydrating.
+     *
+     * @hidden
+     */
+    index?: number;
+    formOptions?: {
+        /**
+         * Title to display on a button when form is submitting.
+         */
+        submittingTitle?: string | null;
+        /**
+         * Title to display on a button when form is in the error state.
+         */
+        errorTitle?: string | null;
+        /**
+         * Title to display on a button when form is in the success state.
+         */
+        successTitle?: string | null;
+    } | null;
+}
+
+/**
+ * @module Notifications
+ */
+/**
+ * Sound options for a notification
+ */
+interface NotificationSoundOptions {
+    /**
+     * Determines the sound that will be played when a notification is received.
+     *
+     * @default 'default' plays the default notification sound.
+     */
+    mode: 'default' | 'silent';
+}
+
+/**
+ * @module Notifications
+ */
+/**
+ * Details of the application that will handle any actions coming from a particular stream.
+ */
+interface NotificationStream {
+    /**
+     * Unique id of the stream.
+     */
+    id: string;
+    /**
+     * Stream title.
+     *
+     * Providing a different displayName for an existing stream id will update the
+     * displayName of the stream stored in Notification Center.
+     *
+     */
+    displayName: string;
+    /**
+     * ID of the application source of this stream.
+     */
+    appId: string;
+}
+
+interface NotificationIndicatorColorsSet {
+    background: string;
+    foreground: string;
+}
+declare module 'styled-components' {
+    interface DefaultTheme {
+        notificationIndicatorColors?: Record<string, NotificationIndicatorColorsSet>;
+    }
+}
+
+/**
+ * @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
+ */
+
+/**
+ * Application-defined context data that can be attached to buttons on notifications.
+ */
+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.
+ */
+type Notification<T extends NotificationOptions = NotificationOptions> = Readonly<Required<DistributiveOmit<T, 'buttons'>> & {
+    readonly buttons: ReadonlyArray<Required<ButtonOptions>>;
+}>;
+
+/**
+ * Persisted modifiers to a notification.
+ * Store changes to a notification here so we do not alter the original notification for historical purposes.
+ */
+interface NotificationModifiers {
+    /**
+     * When a sticky notification has been minimized track its sticky state change here.
+     */
+    notSticky?: boolean;
+    /**
+     * When Notifications are updated a revision number is generated to allow for easier update rendering
+     */
+    revision?: number;
+    /**
+     * The timestamp at which this notification is set to be recreated.
+     */
+    reminder?: number;
+    /**
+     * A flag that indicates that this is a tutorial notification created by the center.
+     * No events dispatch attempts will be done for tutorial notifications.
+     */
+    tutorial?: boolean;
+}
+
+/**
+ * Shape of the data that will be used internally by the service.
+ *
+ * The id property is the encoded notification id (i.e. "{app uuid}/{notification ID}")
+ *
+ */
+type StoredNotification<T extends NotificationOptions = NotificationOptions> = Immutable<{
+    id: string;
+    source: NotificationSource;
+    notification: NotificationInternal<T>;
+    title: string;
+    modifiers?: NotificationModifiers;
+    /**
+     * Stripped text contents of the body without HTML/Markdown. Use this for search
+     */
+    bodyText: string;
+}>;
+
+type StoredApplication = Immutable<ProgrammaticApplication> | Immutable<ManifestApplication> | Immutable<WebApplication>;
+/**
+ * Interface used when reading properties from an application manifest
+ *
+ * Not intended to be a complete list of all properties, only defines the properties that are used by the service.
+ */
+interface Manifest {
+    name?: string;
+    uuid?: string;
+    startup_app?: {
+        uuid: string;
+        name: string;
+        applicationIcon?: string;
+        icon: string;
+    };
+    shortcut?: {
+        name?: string;
+        icon: string;
+    };
+    platform?: {
+        uuid: string;
+    };
+    notifications?: {
+        security?: {
+            notificationRule?: NotificationSecurityRule;
+        };
+    };
+}
+interface StoredApplicationBase {
+    id: string;
+    title: string;
+    muted: boolean;
+    persistToasts: boolean;
+    iconUrl?: string;
+}
+interface ProgrammaticApplication extends StoredApplicationBase {
+    type: 'programmatic';
+    initialOptions: Manifest;
+    parentUuid: string;
+}
+interface ManifestApplication extends StoredApplicationBase {
+    type: 'manifest';
+    manifestUrl: string;
+}
+interface WebApplication extends StoredApplicationBase {
+    type: 'web';
+}
+
+/**
+ * Shape of the internal streams stored in the database.
+ */
+interface StoredStream extends NotificationStream {
+    appId: string;
+    muted: boolean;
+}
+
+declare global {
+    interface Window {
+        search: SearchWindow;
+    }
+}
+interface SearchWindow {
+    minLength: number;
+    useQueryLength: boolean;
+    queryLengthMinus: number;
+    threshold: number;
+    distance: number;
+    useExtendedSearch: boolean;
+    logging: boolean;
+}
+
+type Reminder = {
+    modifiers: {
+        reminder: number;
+    };
+} & StoredNotification;
+type NotificationCenterSnapshot = {
+    applications: StoredApplication[];
+    streams: StoredStream[];
+    notifications: StoredNotification[];
+    reminders: Reminder[];
+};
+type Immutable<T> = {
+    readonly [K in keyof T]: T[K] extends Date ? T[K] : T[K] extends [infer U, infer V] ? Readonly<[Immutable<U>, Immutable<V>]> : T[K] extends (infer U)[] ? ReadonlyArray<U extends object ? Immutable<U> : U> : T[K] extends object ? Immutable<T[K]> : Readonly<T[K]>;
+};
+
+type NotificationCenterTheme = {
+    palette: CustomPaletteSet;
+};
+type NotificationCenterStartupOptions = {
+    /**
+     * A snapshot of a previous state of the Notification Center to be loaded at startup.
+     * @optional
+     */
+    snapshot?: NotificationCenterSnapshot;
+    /**
+     * A Web Notification Center theme to be loaded at startup.
+     * @optional
+     */
+    theme?: NotificationCenterTheme;
+    /**
+     * A custom sound file URL to play when a new notification is created.
+     * - If not provided, Notification Center attempts to load the default 'notification.wav' from the HERE CDN.
+     * - If cross-origin media files are blocked and no customSoundUrl is set, no sound will play—
+     *   even if the user has enabled notification sounds in the settings panel.
+     *
+     * Note: Some audio formats may not be supported by all browsers.
+     *       Make sure to check browser compatibility for your chosen audio format.
+     * @optional
+     */
+    customSoundUrl?: string;
+};
+type NotificationCenterInitOptions = NotificationCenterStartupOptions & {
+    /**
+     * Unique identifier for the Notification Center instance.
+     * Must be a non-empty string that matches the `serviceId` used in the Web Notification Center Client API connection options.
+     */
+    serviceId: string;
+    /**
+     * The `fin` entry point for HERE Core Web integration.
+     * For setup instructions, see: https://www.npmjs.com/package/@openfin/core-web
+     */
+    finContext: OpenFin.Fin<'external connection'>;
+    /**
+     * A container HTML element where the Web Notification Center will be rendered.
+     * The UI is optimized for containers with a width of 345px.
+     */
+    container: HTMLElement;
+};
+type CustomPaletteSet = DefaultPaletteSet & {
+    functional1?: string;
+    functional2?: string;
+    functional3?: string;
+    functional4?: string;
+    functional5?: string;
+    functional6?: string;
+    functional7?: string;
+    functional8?: string;
+    functional9?: string;
+    functional10?: string;
+    statusSuccess?: string;
+    statusWarning?: string;
+    statusCritical?: string;
+    statusActive?: string;
+    inputBackground?: string;
+    inputColor?: string;
+    inputPlaceholder?: string;
+    inputDisabled?: string;
+    inputFocused?: string;
+    inputBorder?: string;
+    textDefault?: string;
+    textHelp?: string;
+    textInactive?: string;
+    background1?: string;
+    background2?: string;
+    background3?: string;
+    background4?: string;
+    background5?: string;
+    background6?: string;
+    contentBackground1?: string;
+    contentBackground2?: string;
+    contentBackground3?: string;
+    contentBackground4?: string;
+    contentBackground5?: string;
+    linkDefault?: string;
+    linkHover?: string;
+};
+type DefaultPaletteSet = {
+    brandPrimary: string;
+    brandSecondary: string;
+    backgroundPrimary: string;
+};
+type ListenerContext = any;
+
+declare function initNotificationCenter(options: NotificationCenterInitOptions): Promise<void>;
+declare function getSnapshot(): NotificationCenterSnapshot;
+declare function applySnapshot(snapshot: NotificationCenterSnapshot): Promise<void>;
+declare function setTheme(theme: NotificationCenterTheme): Promise<void>;
+declare function addNotificationCountListener(listener: (count: number) => void, context?: ListenerContext): void;
+declare function removeNotificationCountListener(listener: (count: number) => void, context?: ListenerContext): void;
+declare function addVisibilityListener(listener: (visible: boolean) => void, context?: ListenerContext): void;
+declare function removeVisibilityListener(listener: (visible: boolean) => void, context?: ListenerContext): void;
+declare function show(): Promise<void>;
+declare function hide(): Promise<void>;
+
+export { addNotificationCountListener, addVisibilityListener, applySnapshot, getSnapshot, hide, initNotificationCenter, removeNotificationCountListener, removeVisibilityListener, setTheme, show };
+export type { CustomPaletteSet, DefaultPaletteSet, ListenerContext, NotificationCenterInitOptions, NotificationCenterSnapshot, NotificationCenterStartupOptions, NotificationCenterTheme };