@openfin/notifications-router 2.13.0-alpha-4294

package/dist/router/index.d.ts

@@ -0,0 +1,2264 @@
+/// <reference types="node" />
+import OpenFin from '@openfin/core';
+import { ThemeSet, ColorSchemeType } from '@openfin/ui-library';
+import { DefaultTheme } from 'styled-components';
+
+type Context = any;
+/**
+ * Signature for an aggregator function.
+ *
+ * On signals that allow callbacks to return a value (i.e. where `R != void`), an aggregator can be used to determine
+ * how the values returned by the signal callbacks are returned back to the code that emitted the signal.
+ *
+ * If no aggregator is provided, the `emit()` function on a signal has a `void` return type.
+ */
+type Aggregator<R, R2> = (items: R[]) => R2;
+/**
+ * Represents a slot that exists on a signal.
+ */
+interface SignalSlot<T extends (...args: any[]) => any> {
+    callback: T;
+    context: Context;
+    remove(): void;
+}
+/**
+ * Signal implementation, a messaging paradigm similar to standard JavaScript events, only more object-based.
+ *
+ * Create a signal for each event type, specifying the types of any callback parameters. Listeners (known as "slots")
+ * can then be added to (and removed from) the signal.
+ *
+ * Unlike events, callbacks are also able to return a value. To make use of these return values, pass an aggregator
+ * function when defining the signal. The static functions within {@link Aggregators} are a set of aggregators that
+ * cover typical use-cases.
+ */
+declare class Signal<A extends any[], R = void, R2 = R> {
+    #private;
+    constructor(aggregator?: Aggregator<R, R2>);
+    get slots(): ReadonlyArray<SignalSlot<(...args: A) => R>>;
+    add(callback: (...args: A) => R, context?: Context): SignalSlot<(...args: A) => R>;
+    remove(callback: (...args: A) => R, context?: Context): boolean;
+    has(callback: (...args: A) => R, context?: Context): boolean;
+    emit(...args: A): R2;
+}
+
+/**
+ * @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;
+
+/**
+ * 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>;
+
+type FormStatus = 'not-submitted' | 'submitting' | 'submitted';
+interface FormStatusOptions {
+    /**
+     * Controls form status,
+     */
+    formStatus: FormStatus;
+    /**
+     * Sets error message at the top of the form.
+     */
+    error?: string;
+    _notificationId: string;
+}
+type CustomValidationError = {
+    fieldKey: string;
+    error: string;
+};
+
+/**
+ * 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;
+}
+
+/**
+ * Configuration options for constructing an updatable Notifications object, shared between all templates.
+ */
+interface BaseUpdatableNotificationOptions<T extends keyof typeof TemplateNames> {
+    /**
+     * A unique identifier for the notification.
+     *
+     * Mandatory field for Notification updates.
+     */
+    id: string;
+    /**
+     * description of update type 'markdown', 'list' or 'custom'
+     */
+    template?: T;
+    /**
+     * 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;
+    /**
+     * 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[];
+}
+
+/**
+ * Default markdown template update.
+ */
+interface UpdatableNotificationTemplateMarkdown extends Omit<BaseUpdatableNotificationOptions<'markdown'>, 'template'> {
+    template?: 'markdown';
+    body?: string;
+    form?: NotificationFormData | null;
+}
+/**
+ * Simple template that can render a list of name-value pairs.
+ */
+interface UpdatableNotificationTemplateList extends BaseUpdatableNotificationOptions<'list'> {
+    /**
+     * Notification list template data.
+     */
+    list?: Record<string, string>;
+}
+/**
+ * Update Payload for Custom Template Notification.
+ * This will let you update the template data associated with the existing template
+ * composition of the notification template.
+ */
+interface UpdatableNotificationTemplateCustom extends BaseUpdatableNotificationOptions<'custom'> {
+    /**
+     * Data associated with the custom notification template's presentation fragments.
+     */
+    templateData?: CustomTemplateData;
+    form?: NotificationFormData | null;
+}
+type UpdatableNotificationOptions = UpdatableNotificationTemplateMarkdown | UpdatableNotificationTemplateList | UpdatableNotificationTemplateCustom;
+
+/**
+ * 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
+ */
+
+/**
+ * Helper to make the `type` field required on any type that defines it as being optional.
+ */
+type WithExplicitType<T extends {
+    type?: string;
+}> = T & {
+    type: string;
+};
+/**
+ * *Not yet implemented*
+ *
+ * Union of the options objects of all "primary control" components supported by the service.
+ */
+type PrimaryControlOptions = never;
+/**
+ * Union of options objects of all components that can be added to a notification, includes both buttons and primary
+ * controls.
+ */
+type ControlOptions = Required<PrimaryControlOptions | WithExplicitType<ButtonOptions>> | WithExplicitType<ActionableTextTemplateFragment> | WithExplicitType<ImageTemplateFragment> | WithExplicitType<ContainerTemplateFragment>;
+/**
+ * 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 Provider
+ */
+/**
+ * Status object returned by the Provider.
+ */
+interface ProviderStatus {
+    /**
+     * The current connection status from the Client to the Provider.
+     */
+    connected: boolean;
+    /**
+     * The version number of the Provider. If the Provider is not connected, this will be `null`.
+     */
+    version: string | null;
+    /**
+     * The version number of the Templates API. If the Provider is not connected, this will be `null`.
+     */
+    templateAPIVersion?: string | null;
+}
+
+/**
+ * @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;
+
+/**
+ * @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 NotificationsThemeSet extends ThemeSet {
+    light: ThemeExtension;
+    dark: ThemeExtension;
+}
+interface ThemeExtension extends DefaultTheme {
+    notificationIndicatorColors?: Record<string, NotificationIndicatorColorsSet>;
+}
+interface NotificationIndicatorColorsSet {
+    background: string;
+    foreground: string;
+}
+declare module 'styled-components' {
+    interface DefaultTheme {
+        notificationIndicatorColors?: Record<string, NotificationIndicatorColorsSet>;
+    }
+}
+
+interface NotificationsPlatform {
+    /**
+     * Unique identifier of the platform.
+     */
+    id: string;
+    /**
+     * Stream title.
+     *
+     * Providing a different displayName for an existing stream id will update the
+     * displayName of the stream stored in Notification Center.
+     *
+     */
+    title: string;
+    /**
+     * URL of the icon to be displayed for this platform.
+     */
+    icon: string;
+    /**
+     * This is the theme associated with this platform. The center will be themed accordingly
+     * when the platform is selected.
+     */
+    theme?: NotificationsThemeSet;
+    /**
+     * This is the scheme associated with this platform.
+     */
+    scheme?: ColorSchemeOption;
+    /**
+     *  Workspace platform that registers this platform
+     */
+    workspacePlatform?: {
+        /**
+         * @deprecated
+         */
+        identity: OpenFin.ApplicationIdentity;
+        analytics: {
+            isSupported: boolean;
+        };
+    };
+    platformIdentity: OpenFin.ApplicationIdentity;
+}
+type PlatformRegisterPayload<T extends NotificationsPlatform = NotificationsPlatform> = Omit<T, 'platformIdentity'>;
+interface PlatformDeregisterPayload {
+    id: string;
+}
+
+/**
+ * @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>>;
+}>;
+/**
+ * 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"
+ */
+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"
+ */
+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"
+ */
+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"
+ */
+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"
+ */
+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"
+ */
+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"
+ */
+interface NotificationsCountChanged {
+    type: 'notifications-count-changed';
+    /**
+     * Number of notifications in the Center.
+     */
+    count: number;
+}
+/**
+ * Event fired whenever any of the notification form fields changes.
+ *
+ * @event "notification-form-value-changed"
+ */
+interface NotificationFormValuesChangedEvent {
+    type: 'notification-form-values-changed';
+    notification: Notification;
+    form: Record<string, unknown>;
+    /**
+     * Allows to set validation errors for the form fields.
+     * If validation errors are set, the submit button will be disabled.
+     * @param validationErrors
+     * Array of objects with fieldKey and error properties.
+     * @returns
+     * Promise that resolves when the validation errors are set.
+     *
+     * @example
+     * addEventListener(
+     *   'notification-form-values-changed',
+     *   async (formValueChanged: NotificationFormValuesChangedEvent) => {
+     *     const errors = [];
+     *
+     *     // Simpler regular expression to test for a valid HTTP or HTTPS URL
+     *     const phonePattern = /^\(?([0-9]{3})\)?[- ]?([0-9]{3})[- ]?([0-9]{4})$/;
+     *
+     *     // Simpler regular expression to test for a valid email address
+     *     const emailPattern = /^\S+@\S+\.\S+$/;
+     *
+     *     // Fields to validate
+     *     const sourcePhone = formValueChanged.form.sourcePhone as string;
+     *     const email = formValueChanged.form.sourceEmail as string;
+     *
+     *     // Validate sourceUrl if it's not null or undefined
+     *     if (sourcePhone && !phonePattern.test(sourcePhone)) {
+     *       errors.push({
+     *         fieldKey: 'sourcePhone',
+     *         error: 'Invalid phone format'
+     *       });
+     *     }
+     *
+     *     // Validate email if it's not null or undefined
+     *     if (email && !emailPattern.test(email)) {
+     *       errors.push({
+     *         fieldKey: 'sourceEmail',
+     *         error: 'Invalid email format'
+     *       });
+     *     }
+     *
+     *     // If there are any errors, set them all at once
+     *     if (errors.length > 0) {
+     *       await formValueChanged.setErrors(errors);
+     *     }
+     *   }
+     * );
+     */
+    setErrors: (validationErrors: Array<CustomValidationError>) => Promise<void>;
+}
+/**
+ * Event fired whenever submit button is clicked on a notification form.
+ *
+ * @event "notification-form-submitted"
+ */
+interface NotificationFormSubmittedEvent {
+    type: 'notification-form-submitted';
+    notification: Notification;
+    button: ButtonOptions;
+    form: Record<string, unknown>;
+    /**
+     * Prevents the default behaviour of notification form submit, where notification card gets dismissed right after submit.
+     *
+     * @example
+     * addEventListener('notification-form-submitted', async (event) => {
+     *     // preventing the default submit behaviour
+     *     event.preventDefault();
+     *
+     *     // setting the form status to processing
+     *     event.setFormStatus({
+     *       formStatus: 'Processing'
+     *     });
+     *
+     *     const longOperationResult = await ...();
+     *
+     *     if (longOperationResult.hasError) {
+     *        // setting error if long-running operation has failed.
+     *        event.setFormStatus({
+     *           formStatus: 'not-submitted',
+     *           error: longOperationResult.operationErrorMessage
+     *         });
+     *     } else {
+     *        // setting form status to submitted
+     *        event.setFormStatus({
+     *          formStatus: 'submitted'
+     *        });
+     *     }
+     *   });
+     */
+    preventDefault: () => void;
+    /**
+     *
+     * @param formStatusOptions
+     * Allows to set the status of the form. The form status reflects the state of the submit button which includes its text.
+     * Submit button text for different statuses is defined using `formOptions` property for a submit button when creating a notification.
+     *
+     * @example
+     * addEventListener('notification-form-submitted', async (event) => {
+     *     // preventing the default submit behaviour
+     *     event.preventDefault();
+     *
+     *     // setting the form status to processing
+     *     event.setFormStatus({
+     *       formStatus: 'Processing'
+     *     });
+     *
+     *     const longOperationResult = await ...();
+     *
+     *     if (longOperationResult.hasError) {
+     *        // setting error if long-running operation has failed.
+     *        event.setFormStatus({
+     *           formStatus: 'not-submitted',
+     *           error: longOperationResult.operationErrorMessage
+     *         });
+     *     } else {
+     *        // setting form status to submitted
+     *        event.setFormStatus({
+     *          formStatus: 'submitted'
+     *        });
+     *     }
+     *  });
+     */
+    setFormStatus: (formStatusOptions: Omit<FormStatusOptions, '_notificationId'>) => Promise<void>;
+}
+/**
+ * Event fired whenever the Notification Sound Enabled setting is toggled in Notification Center.
+ *
+ * @event "notification-sound-toggled"
+ */
+interface ToggleNotificationSound {
+    type: 'notification-sound-toggled';
+    notificationSoundEnabled: boolean;
+}
+/**
+ * Extended configuration options for the notification creation.
+ */
+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, 2025 07:28:00');
+ * });
+ * ```
+ *
+ * @param options Notification configuration options.
+ * @param creationOptions Extended configuration options for the notification creation.
+ */
+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
+ */
+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.
+ */
+declare function clear(id: string): Promise<boolean>;
+/**
+ * Sets a reminder for a specific notification. Reminder must be a date in the future.
+ *
+ * ```ts
+ * import {setReminder} from 'openfin-notifications';
+ *
+ * // Set a reminder 1 minute from now
+ * setReminder('uniqueNotificationId', new Date(Date.now() + 60_000));
+ *
+ * // Set a reminder for a specific date
+ * setReminder('uniqueNotificationId', new Date('October 21, 2025 07:28:00'));
+ * ```
+ *
+ * @param id ID of the notification to set the reminder for.
+ * @param reminderDate Reminder date.
+ * @returns True if the reminder was set successfully, false otherwise.
+ */
+declare function setReminder(id: string, reminderDate: Date): Promise<boolean>;
+/**
+ * Cancels a reminder for a specific notification.
+ *
+ * ```ts
+ * import {cancelReminder} from 'openfin-notifications';
+ *
+ * cancelReminder('uniqueNotificationId');
+ * ```
+ * @param id ID of the notification to cancel the reminder for.
+ * @returns True if the reminder was canceled successfully, false otherwise.
+ */
+declare function cancelReminder(id: string): Promise<boolean>;
+/**
+ * Retrieves all Notifications which were created by the calling application, including child windows.
+ * Child window notifications will only be included if the notification security rules allow it.
+ *
+ * ```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.
+ */
+declare function getAll(): Promise<Notification[]>;
+/**
+ * Clears all Notifications which were created by the calling application, including child windows.
+ * Child window notifications will only be cleared if the notification security rules allow it.
+ *
+ * Returns the number of successfully cleared Notifications.
+ *
+ * ```ts
+ * import {clearAll} from 'openfin-notifications';
+ *
+ * clearAll();
+ * ```
+ */
+declare function clearAll(): Promise<number>;
+/**
+ * Options to modify the Notification Center behaviour when show() API is called.
+ */
+interface ShowOptions {
+    navigateToAll?: boolean;
+}
+/**
+ * Sets the visibility of the Notification Center to true.
+ *
+ * ```ts
+ * import { show } from 'openfin-notifications';
+ *
+ * show({ navigateToAll: false });
+ * ```
+ * @param showOptions
+ */
+declare function show(options?: ShowOptions): Promise<void>;
+declare const enum UserSettings {
+    SOUND_ENABLED = "soundEnabled"
+}
+type UserSettingStatus = {
+    [UserSettings.SOUND_ENABLED]: boolean;
+};
+
+/**
+ * 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;
+/**
+ * Lists the different triggers that can raise an {@link Actions|action}. Each action that is raised will result in a
+ * {@link NotificationActionEvent|`notification-action`} event, which can be captured by the application that created
+ * the notification.
+ */
+declare enum ActionTrigger {
+    /**
+     * The user interacted with one of the controls in the notification: a button or an actionable fragment.
+     */
+    CONTROL = "control",
+    /**
+     * The user clicked the body of the notification itself. Any clicks of the notification that don't hit a control
+     * or the close button will fire an event with the `'select'` action trigger.
+     */
+    SELECT = "select",
+    /**
+     * The notification was closed, either by user interaction, programmatically by an application, or by the notification expiring.
+     */
+    CLOSE = "close",
+    /**
+     * The notification expired.
+     */
+    EXPIRE = "expire",
+    /**
+     * The action was triggered programmatically by an application.
+     *
+     * *Not currently supported*
+     */
+    PROGRAMMATIC = "programmatic"
+}
+/**
+ * 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;
+}
+
+/**
+ * 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[];
+}
+
+declare global {
+    interface Window {
+        search: SearchWindow;
+    }
+}
+interface SearchWindow {
+    minLength: number;
+    useQueryLength: boolean;
+    queryLengthMinus: number;
+    threshold: number;
+    useExtendedSearch: boolean;
+    logging: boolean;
+}
+
+/**
+ * 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;
+}
+
+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]>;
+};
+
+/**
+ * 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;
+}>;
+
+/**
+ * @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.
+ */
+
+declare const enum APITopic {
+    CREATE_NOTIFICATION = "create-notification",
+    UPDATE_NOTIFICATION = "update-notification",
+    CLEAR_NOTIFICATION = "clear-notification",
+    SET_REMINDER = "set-reminder",
+    CANCEL_REMINDER = "cancel-reminder",
+    GET_APP_NOTIFICATIONS = "fetch-app-notifications",
+    CLEAR_APP_NOTIFICATIONS = "clear-app-notifications",
+    TOGGLE_NOTIFICATION_CENTER = "toggle-notification-center",
+    ADD_EVENT_LISTENER = "add-event-listener",
+    REMOVE_EVENT_LISTENER = "remove-event-listener",
+    GET_PROVIDER_STATUS = "get-provider-status",
+    GET_NOTIFICATIONS_COUNT = "get-notifications-count",
+    SHOW_NOTIFICATION_CENTER = "show-notification-center",
+    HIDE_NOTIFICATION_CENTER = "hide-notification-center",
+    REGISTER_PLATFORM = "register-notifications-platform",
+    DEREGISTER_PLATFORM = "deregister-notifications-platform",
+    SET_FORM_STATUS_OPTIONS = "set-form-status-options",
+    SET_FORM_VALIDATION_ERRORS = "set-form-validation-errors",
+    GET_USER_SETTINGS_STATUS = "get-user-settings-status",
+    SET_DEFAULT_PLATFORM_SHORTCUT = "set-default-platform-shortcut",
+    SET_NOTIFICATION_SECURITY_RULE = "set-notification-security-rule"
+}
+interface API {
+    [APITopic.CREATE_NOTIFICATION]: [CreatePayload, NotificationInternal];
+    [APITopic.UPDATE_NOTIFICATION]: [UpdatePayload, NotificationInternal];
+    [APITopic.CLEAR_NOTIFICATION]: [ClearPayload, boolean];
+    [APITopic.SET_REMINDER]: [SetReminderPayload, boolean];
+    [APITopic.CANCEL_REMINDER]: [CancelReminderPayload, boolean];
+    [APITopic.CLEAR_APP_NOTIFICATIONS]: [undefined, number];
+    [APITopic.GET_APP_NOTIFICATIONS]: [undefined, NotificationInternal[]];
+    [APITopic.TOGGLE_NOTIFICATION_CENTER]: [undefined, void];
+    [APITopic.ADD_EVENT_LISTENER]: [Events['type'], void];
+    [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.SET_FORM_STATUS_OPTIONS]: [FormStatusOptions, void];
+    [APITopic.SET_FORM_VALIDATION_ERRORS]: [SetFormValidationErrorsPayload, void];
+    [APITopic.GET_USER_SETTINGS_STATUS]: [UserSettings, UserSettingStatus[UserSettings]];
+    [APITopic.SET_DEFAULT_PLATFORM_SHORTCUT]: [string, void];
+    [APITopic.SET_NOTIFICATION_SECURITY_RULE]: [NotificationSecurityRule, void];
+}
+type Events = NotificationActionEvent | NotificationToastDismissedEvent | NotificationClosedEvent | NotificationCreatedEvent | NotificationsCountChanged | Omit<NotificationFormSubmittedEvent, 'setFormStatus' | 'preventDefault'> | NotificationReminderCreatedEvent | NotificationReminderRemovedEvent | Omit<NotificationFormValuesChangedEvent, 'setErrors'> | ToggleNotificationSound;
+type TransportMappings<T> = T extends NotificationActionEvent ? NotificationActionEventTransport : never;
+type TransportMemberMappings<T> = T extends Notification ? NotificationInternal : T;
+type CreatePayload<T extends NotificationOptions = NotificationOptions> = DistributiveOmit<T, 'date' | 'expires'> & {
+    date?: number;
+    expires?: number | null;
+    reminder?: number | null;
+};
+type SetFormValidationErrorsPayload = {
+    errors: Array<CustomValidationError>;
+    notificationId: string;
+};
+type UpdatePayload<T extends UpdatableNotificationOptions = UpdatableNotificationOptions> = T;
+type NotificationInternal<T extends NotificationOptions = NotificationOptions> = DistributiveOmit<Notification<T>, 'date' | 'expires'> & {
+    date: number;
+    expires: number | null;
+    _fragments?: (ActionableTextTemplateFragment | ImageTemplateFragment | ContainerTemplateFragment)[];
+};
+type SetReminderPayload<T extends NotificationOptions = NotificationOptions> = {
+    id: string;
+    reminder: number;
+} | {
+    notification: StoredNotification<T>;
+    reminder: number;
+};
+interface CancelReminderPayload {
+    id: string;
+}
+interface ClearPayload {
+    id: string;
+}
+type ShowPayload = ShowOptions;
+type ColorSchemeOption = ColorSchemeType;
+interface NotificationActionEventTransport {
+    type: 'notification-action';
+    notification: Readonly<NotificationInternal>;
+    source: NotificationSource;
+    result: NotificationActionResult;
+    trigger: ActionTrigger;
+    controlSource?: 'buttons' | '_fragments';
+    controlIndex?: number;
+}
+/**
+ * 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;
+/**
+ * Data returned by the service when registering a platform.
+ */
+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;
+}
+type MakePropertyRequired<T, Prop extends keyof T> = Omit<T, Prop> & Required<Pick<T, Prop>>;
+
+/**
+ * @hidden
+ */
+/**
+ * Acts as a central point for routing all events received from the provider.
+ */
+
+interface EventSpecification {
+    type: string;
+}
+interface EventTarget {
+    type: string;
+    id: string;
+}
+type Targeted<T extends EventSpecification> = T & {
+    /**
+     * Indicates which emitter the client should use to dispatch this event.
+     *
+     * Allows events to be raised from client-side objects that mirror a corresponding provider-side object. If there
+     * is no such model of client-side objects, pass `default` to emit the event from a shared top-level/"global" event
+     * emitter.
+     */
+    target: EventTarget | 'default';
+};
+type Transport<T extends EventSpecification> = TransportMappings<T> extends never ? {
+    [K in keyof T]: TransportMemberMappings<T[K]>;
+} : TransportMappings<T>;
+
+/**
+ * Defines a tuple that stores the payload and return type of an API method.
+ *
+ * The first element will be an interface containing the "payload" of the API - an object containing any parameters
+ * that need to be passed from client to provider.
+ *
+ * The second element is the return type of the API - the type (possibly `void`) that is passed from the provider back
+ * to the client.
+ */
+type APIDefinition = [unknown, unknown];
+
+/**
+ * Options for using privately hosted notification service.
+ * @deprecated This option is not supported anymore. This configuration must be provided via the host platform's manifest.
+ */
+type CustomManifestOptions = {
+    /**
+     * A custom manifest location to start the notification service from.
+     * The UUID cannot be OpenFin hosted Notification Service UUID, 'notifications-service'.
+     */
+    manifestUrl: string;
+    /**
+     * The UUID of the provided custom notifications service manifest.
+     * This value **MUST** match the UUID of the manifest provided in `manifestUrl`.
+     */
+    manifestUuid: string;
+};
+
+type APIPayloadTranformer<T extends APIDefinition> = (payload: T[0]) => T[0] | Promise<T[0]>;
+type APIPayloadTransformerMap = {
+    [K in APITopic]: APIPayloadTranformer<API[K]>;
+};
+type APIOverrides = Partial<APIPayloadTransformerMap>;
+type NotificationCenterEvent = Targeted<Transport<Events>>;
+type WakeUpCallback = (contentId: string, eventType: Events['type']) => Promise<void>;
+type OnNotificationCenterEvent = (payload: NotificationCenterEvent, contentId?: string) => Promise<void>;
+type APIRouterConfig = {
+    providerChannelName: string;
+    onWakeUpRequired: WakeUpCallback;
+    onNotificationCenterEvent?: OnNotificationCenterEvent;
+    overrides?: APIOverrides;
+    customManifest?: CustomManifestOptions;
+};
+declare class APIRouter {
+    #private;
+    readonly onConnection: Signal<[OpenFin.Identity]>;
+    readonly onDisconnection: Signal<[OpenFin.Identity]>;
+    constructor(config: APIRouterConfig);
+    initialize(): Promise<void>;
+}
+
+export { APIRouter, APITopic, cancelReminder, clear, clearAll, create, getAll, setReminder, show, update };
+export type { API, APIOverrides, APIPayloadTranformer, APIPayloadTransformerMap, APIRouterConfig, CancelReminderPayload, ClearPayload, CreatePayload, Events, NotificationCenterEvent, NotificationInternal, NotificationOptions, OnNotificationCenterEvent, SetFormValidationErrorsPayload, SetReminderPayload, ShowPayload, UpdatableNotificationOptions, UpdatePayload, WakeUpCallback };