@openfin/core 33.76.18 → 33.76.19

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@openfin/core",
-    "version": "33.76.18",
+    "version": "33.76.19",
     "license": "SEE LICENSE IN LICENSE.MD",
     "main": "./src/mock.js",
     "types": "./src/mock.d.ts",

package/src/OpenFin.d.ts

@@ -3002,6 +3002,7 @@ export type AppVersionRuntimeStatusEvent = {
     type: 'runtime-status';
 } & AppVersionRuntimeInfo;
 import type * as BaseEvents from './api/events/base';
+import type * as ChannelEvents from './api/events/channel';
 import type * as WebContentsEvents from './api/events/webcontents';
 import type * as SystemEvents from './api/events/system';
 import type * as ApplicationEvents from './api/events/application';
@@ -3011,8 +3012,9 @@ import type * as GlobalHotkeyEvents from './api/events/globalHotkey';
 import type * as FrameEvents from './api/events/frame';
 import type * as PlatformEvents from './api/events/platform';
 import type * as ExternalApplicationEvents from './api/events/externalApplication';
-export type { BaseEvents, WebContentsEvents, SystemEvents, ApplicationEvents, WindowEvents, ViewEvents, GlobalHotkeyEvents, FrameEvents, PlatformEvents, ExternalApplicationEvents };
+export type { BaseEvents, ChannelEvents, WebContentsEvents, SystemEvents, ApplicationEvents, WindowEvents, ViewEvents, GlobalHotkeyEvents, FrameEvents, PlatformEvents, ExternalApplicationEvents };
 export type BaseEvent = BaseEvents.BaseEvent;
+export type ChannelEvent = ChannelEvents.ChannelEvent;
 export type WebContentsEvent = WebContentsEvents.WebContentsEvent;
 export type SystemEvent = SystemEvents.SystemEvent;
 export type ApplicationEvent = ApplicationEvents.ApplicationEvent;

package/src/api/events/application.d.ts

@@ -2,6 +2,9 @@ import type * as OpenFin from '../../OpenFin';
 import { IdentityEvent, NamedEvent, PropagatedEvent } from './base';
 import { PropagatedWindowEvent } from './window';
 import { PropagatedViewEvent } from './view';
+/**
+ * Generated when an application has crashed.
+ */
 export type CrashedEvent = NamedEvent & {
     type: 'crashed';
     reason: 'normal-termination' | 'abnormal-termination' | 'killed' | 'crashed' | 'still-running' | 'launch-failed' | 'out-of-memory' | 'integrity-failure';
@@ -11,14 +14,24 @@ export type CrashedEvent = NamedEvent & {
         exitCode: number;
     };
 };
+/**
+ * Generated when setFileDownloadLocation api is called.
+ * @remarks This event will not include the file download location itself. In order to get the new file download location, the user will have to access the secured query API 'getFileDownloadLocation'.
+ */
 export type FileDownloadLocationChangedEvent = NamedEvent & {
     type: 'file-download-location-changed';
 };
+/**
+ * Generated when Application.run() is called for an already running application.
+ */
 export type RunRequestedEvent = IdentityEvent & {
     type: 'run-requested';
     userAppConfigArgs: Record<string, any>;
     manifest: OpenFin.ManifestInfo;
 };
+/**
+ * Generated when the tray icon is clicked.
+ */
 export type TrayIconClickedEvent = IdentityEvent & {
     type: 'tray-icon-clicked';
     button: 0 | 1 | 2;
@@ -27,21 +40,39 @@ export type TrayIconClickedEvent = IdentityEvent & {
     y: number;
     monitorInfo: any;
 };
+/**
+ * Generated when an alert is fired and suppressed due to the customWindowAlert flag being true.
+ */
 export type WindowAlertRequestedEvent = NamedEvent & {
     type: 'window-alert-requested';
 };
+/**
+ * Generated when a child window is created.
+ */
 export type WindowCreatedEvent = NamedEvent & {
     type: 'window-created';
 };
+/**
+ * Generated when a child window ends loading.
+ */
 export type WindowEndLoadEvent = NamedEvent & {
     type: 'window-end-load';
 };
+/**
+ * Generated when a child window is not responding.
+ */
 export type WindowNotRespondingEvent = NamedEvent & {
     type: 'window-not-responding';
 };
+/**
+ * Generated when a child window is responding.
+ */
 export type WindowRespondingEvent = NamedEvent & {
     type: 'window-responding';
 };
+/**
+ * Generated when a child window starts loading.
+ */
 export type WindowStartLoadEvent = NamedEvent & {
     type: 'window-start-load';
 };
@@ -49,24 +80,45 @@ export type WindowStartLoadEvent = NamedEvent & {
  * A Window event that is natively published at the Application level (not Window).
  */
 export type ApplicationWindowEvent = WindowAlertRequestedEvent | WindowCreatedEvent | WindowEndLoadEvent | WindowNotRespondingEvent | WindowRespondingEvent | WindowStartLoadEvent;
+/**
+ * Generated when an application is closed.
+ */
 export type ClosedEvent = IdentityEvent & {
     type: 'closed';
 };
+/**
+ * Generated when an application has authenticated and is connected.
+ */
 export type ApplicationConnectedEvent = IdentityEvent & {
     type: 'connected';
 };
+/**
+ * Generated when an application has initialized.
+ */
 export type InitializedEvent = IdentityEvent & {
     type: 'initialized';
 };
+/**
+ * Generated when the RVM notifies an application that the manifest has changed.
+ */
 export type ManifestChangedEvent = IdentityEvent & {
     type: 'manifest-changed';
 };
+/**
+ * Generated when an application is not responding.
+ */
 export type NotRespondingEvent = IdentityEvent & {
     type: 'not-responding';
 };
+/**
+ * Generated when an application is responding.
+ */
 export type RespondingEvent = IdentityEvent & {
     type: 'responding';
 };
+/**
+ * Generated when an application has started.
+ */
 export type StartedEvent = IdentityEvent & {
     type: 'started';
 };
@@ -74,9 +126,21 @@ export type StartedEvent = IdentityEvent & {
  * An Application event that does propagate to (republish on) parent topics.
  */
 export type WillPropagateApplicationEvent = ClosedEvent | ApplicationConnectedEvent | CrashedEvent | InitializedEvent | ManifestChangedEvent | NotRespondingEvent | RespondingEvent | RunRequestedEvent | StartedEvent | TrayIconClickedEvent | FileDownloadLocationChangedEvent;
+/**
+ *  An Application event.
+ */
 export type ApplicationEvent = {
     topic: 'application';
 } & (PropagatedViewEvent | PropagatedWindowEvent | ApplicationWindowEvent | WillPropagateApplicationEvent);
+/**
+ * An Application event type.
+ */
 export type ApplicationEventType = ApplicationEvent['type'];
+/**
+ * A propagated Application event.
+ */
 export type PropagatedApplicationEvent = PropagatedEvent<'application', WillPropagateApplicationEvent> | ApplicationWindowEvent;
+/**
+ * A propagated Application event type.
+ */
 export type PropagatedApplicationEventType = PropagatedApplicationEvent['type'];

package/src/api/events/base.d.ts

@@ -3,8 +3,8 @@
  */
 export type PropagatedEventType<Topic extends string, Type extends string> = `${Topic}-${Type}`;
 /**
- * Modifies an event shape to reflect propagation to a parent topic.  The 'type' field
- * is prefixed with the original topic, and a new property is added with the original topic's identity.
+ * Modifies an event shape to reflect propagation to a parent topic.
+ * @remarks The 'type' field is prefixed with the original topic, and a new property is added with the original topic's identity.
  */
 export type PropagatedEvent<Topic extends string, Event extends {
     type: string;
@@ -14,19 +14,29 @@ export type PropagatedEvent<Topic extends string, Event extends {
     type: PropagatedEventType<Topic, E['type']>;
 } : never;
 /**
- * Handler for an event on an EventEmitter; selects the correct type for the event
+ * Handler for an event on an EventEmitter.
+ * @remarks Selects the correct type for the event
  * payload from the provided union based on the provided string literal type.
  */
 export type EventHandler<EmitterEvent extends BaseEvent, EventType extends string> = (payload: Extract<EmitterEvent, {
     type: EventType;
 }>, ...args: any[]) => void;
+/**
+ * A base event.
+ */
 export type BaseEvent = {
     topic: string;
     type: string;
 };
+/**
+ * An Identity event.
+ */
 export type IdentityEvent = BaseEvent & {
     uuid: string;
 };
+/**
+ * A Name event.
+ */
 export type NamedEvent = IdentityEvent & {
     name: string;
 };

package/src/api/events/channel.d.ts

@@ -1,15 +1,30 @@
 import { NamedEvent } from './base';
+/**
+ * A base Channel event.
+ */
 export type BaseChannelEvent = NamedEvent & {
     channelName: string;
     channelId: string;
 };
+/**
+ * Generated when a Channel client is connected.
+ */
 export type ChannelConnectedEvent = BaseChannelEvent & {
     type: 'connected';
 };
+/**
+ * Generated when a Channel client has disconnected.
+ */
 export type ChannelDisconnectedEvent = BaseChannelEvent & {
     type: 'disconnected';
 };
+/**
+ * A Channel event.
+ */
 export type ChannelEvent = {
     topic: 'channel';
 } & (ChannelConnectedEvent | ChannelDisconnectedEvent);
+/**
+ * A Channel event type.
+ */
 export type ChannelEventType = ChannelEvent['type'];

package/src/api/events/externalApplication.d.ts

@@ -1,10 +1,19 @@
 import { BaseEvent } from './base';
+/**
+ * Generated when an external application has authenticated and is connected.
+ */
 export type ExternalApplicationConnectedEvent = BaseEvent & {
     type: 'connected';
 };
+/**
+ * Generated when an external application has disconnected.
+ */
 export type ExternalApplicationDisconnectedEvent = BaseEvent & {
     type: 'disconnected';
 };
+/**
+ * An external application event.
+ */
 export type ExternalApplicationEvent = {
     topic: 'externalapplication';
 } & (ExternalApplicationConnectedEvent | ExternalApplicationDisconnectedEvent);

package/src/api/events/frame.d.ts

@@ -1,15 +1,30 @@
 import { NamedEvent } from './base';
+/**
+ * The base frame event.
+ */
 export type BaseFrameEvent = NamedEvent & {
     entityType: 'iframe';
     frameName: string;
 };
+/**
+ * Generated when a frame is connected.
+ */
 export type FrameConnectedEvent = BaseFrameEvent & {
     type: 'connected';
 };
+/**
+ * Generated when a frame has disconnected.
+ */
 export type FrameDisconnectedEvent = BaseFrameEvent & {
     type: 'disconnected';
 };
+/**
+ * A Frame event.
+ */
 export type FrameEvent = {
     topic: 'frame';
 } & (FrameConnectedEvent | FrameDisconnectedEvent);
+/**
+ * A Frame event type.
+ */
 export type FrameEventType = FrameEvent['type'];

package/src/api/events/globalHotkey.d.ts

@@ -1,10 +1,19 @@
 import { BaseEvent } from './base';
+/**
+ * Generated when a hotkey has been registered with the operating system.
+ */
 export type RegisteredEvent = BaseEvent & {
     type: 'registered';
 };
+/**
+ * Generated when a hotkey has been unregistered with the operating system.
+ */
 export type UnregisteredEvent = BaseEvent & {
     type: 'unregistered';
 };
+/**
+ * A global hotkey event.
+ */
 export type GlobalHotkeyEvent = {
     topic: 'global-hotkey';
     hotkey: 'string';

package/src/api/events/platform.d.ts

@@ -1,11 +1,26 @@
 import { ApplicationEvent } from './application';
 import { BaseEvent } from './base';
+/**
+ * Generated when a new Platform's API becomes responsive.
+ */
 export type PlatformApiReadyEvent = BaseEvent & {
     topic: 'application';
     type: 'platform-api-ready';
 };
+/**
+ * Generated when a <a href="tutorial-Platform.applySnapshot.html">platform.ApplySnapshot</a> call is resolved.
+ * @remarks The call is resolved when the following conditions are met for all windows in the snapshot:
+ * 1. The window has been created
+ * 2. The window has a responsive API
+ * 3. If a window has a layout property, the 'layout-ready' event has fired
+ *
+ * _Note_ - In the case of using a custom provider, if a window has a layout property but does not call _Layout.init_ this event may not fire.
+ */
 export type PlatformSnapshotAppliedEvent = BaseEvent & {
     topic: 'application';
     type: 'platform-snapshot-applied';
 };
+/**
+ * A Platform event.
+ */
 export type PlatformEvent = ApplicationEvent | PlatformApiReadyEvent | PlatformSnapshotAppliedEvent;

package/src/api/events/system.d.ts

@@ -4,32 +4,73 @@ import { BaseEvent, IdentityEvent } from './base';
 import { PropagatedViewEvent } from './view';
 import { PropagatedWindowEvent } from './window';
 import { AppVersionCompleteEvent, AppVersionErrorEvent, AppVersionProgressEvent, AppVersionRuntimeStatusEvent } from '../../OpenFin';
+/**
+ * @internal
+ */
 export type NotRequested<EventType> = EventType extends `${infer U}-requested` ? never : EventType;
+/**
+ * @internal
+ */
 export type ExcludeRequested<Event extends {
     type: string;
 }> = Extract<Event, {
     type: NotRequested<Event['type']>;
 }>;
+/**
+ * Generated when a user enters or returns from idle state.
+ * @remarks This method is continuously generated every minute while the user is in idle.
+ * A user enters idle state when the computer is locked or when there has been no keyboard/mouse activity for 1 minute.
+ * A user returns from idle state when the computer is unlocked or keyboard/mouse activity has resumed.
+ */
 export type IdleEvent = {
     type: 'idle-state-changed';
     elapsedTime: number;
     isIdle: boolean;
 };
+/**
+ * Generated on changes of a monitor's size/location.
+ * @remarks A monitor's size changes when the taskbar is resized or relocated.
+ * The available space of a monitor defines a rectangle that is not occupied by the taskbar
+ */
 export type MonitorEvent = OpenFin.MonitorInfo & {
     type: 'monitor-info-changed';
 };
+/**
+ * Generated on changes to a user’s local computer session.
+ */
 export type SessionChangedEvent = {
     type: 'session-changed';
     reason: 'lock' | 'unlock' | 'remote-connect' | 'remote-disconnect' | 'unknown';
 };
+/**
+ * An app versioning event.
+ */
 export type AppVersionEvent = AppVersionProgressEvent | AppVersionRuntimeStatusEvent | AppVersionCompleteEvent | AppVersionErrorEvent;
+/**
+ * An app versioning event type.
+ */
 export type AppVersionEventType = AppVersionEvent['type'];
+/**
+ * @internal
+ */
 export type IdEventType = WithId<AppVersionEventType>;
+/**
+ * @internal
+ */
 export type WithId<T extends AppVersionEventType> = `${T}.${string}`;
+/**
+ * @internal
+ */
 export type WithoutId<T extends string> = T extends WithId<infer U> ? U : never;
+/**
+ * @internal
+ */
 export type AppVersionTypeFromIdEvent<T extends IdEventType> = Extract<AppVersionEvent, {
     type: WithoutId<T>;
 }>;
+/**
+ * @internal
+ */
 export type EventWithId<Event extends AppVersionEvent> = Event extends infer E extends {
     type: AppVersionEventType;
 } ? Omit<E, 'type'> & {
@@ -37,17 +78,36 @@ export type EventWithId<Event extends AppVersionEvent> = Event extends infer E e
     topic: 'system';
     appVersionId: string;
 } : never;
+/**
+ * @internal
+ */
 export type AppVersionEventWithId = EventWithId<AppVersionEvent>;
+/**
+ * Generated when an application is created.
+ */
 export type ApplicationCreatedEvent = IdentityEvent & {
     type: 'application-created';
 };
+/**
+ * Generated when the desktop icon is clicked while it's already running.
+ */
 export type DesktopIconClickedEvent = BaseEvent & {
     type: 'desktop-icon-clicked';
 };
+/**
+ * Generated when system shutdown or log off.
+ * @internal
+ */
 export type SystemShutdownEvent = BaseEvent & {
     type: 'system-shutdown';
 };
+/**
+ * A system event.
+ */
 export type SystemEvent = {
     topic: 'system';
 } & (ExcludeRequested<PropagatedWindowEvent> | PropagatedViewEvent | PropagatedApplicationEvent | ApplicationCreatedEvent | DesktopIconClickedEvent | IdleEvent | MonitorEvent | SessionChangedEvent | AppVersionEventWithId | SystemShutdownEvent);
+/**
+ * A system event type.
+ */
 export type SystemEventType = SystemEvent['type'];

package/src/api/events/view.d.ts

@@ -1,10 +1,18 @@
 import type * as OpenFin from '../../OpenFin';
 import { NonPropagatedWebContentsEvent, WillPropagateWebContentsEvent } from './webcontents';
 import { NamedEvent, PropagatedEvent } from './base';
+/**
+ * A base View event.
+ */
 export type BaseViewEvent = {
     target: OpenFin.Identity;
     viewIdentity: OpenFin.Identity;
 };
+/**
+ * Generated when a View changes its window target.
+ * @remarks This event will fire during creation of a View.
+ * In that case, previousTarget identity will be the same as target identity.
+ */
 export type TargetChangedEvent = NamedEvent & {
     type: 'target-changed';
     previousTarget: OpenFin.Identity;
@@ -13,21 +21,40 @@ export type TargetChangedEvent = NamedEvent & {
  * A View event that does not propagate to (republish on) parent topics.
  */
 export type NonPropagatedViewEvent = BaseViewEvent & NonPropagatedWebContentsEvent;
+/**
+ * Generated when a View is attached to a window.
+ */
 export type AttachedEvent = NamedEvent & {
     type: 'attached';
 };
+/**
+ * Generated when a View is created.
+ */
 export type CreatedEvent = NamedEvent & {
     type: 'created';
 };
+/**
+ * Generated when a View is destroyed.
+ */
 export type DestroyedEvent = NamedEvent & {
     type: 'destroyed';
 };
+/**
+ * Generated when a View is hidden.
+ */
 export type HiddenEvent = NamedEvent & {
     type: 'hidden';
 };
+/**
+ * Generated when a keyboard shortcut defined in the `hotkeys` array in [View options](OpenFin.ViewOptions.html) is pressed inside the view.
+ * @remarks For reference on keyboard event properties see [KeyboardEvent](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent).
+ */
 export type HotkeyEvent = NamedEvent & {
     type: 'hotkey';
 };
+/**
+ * Generated when a View is shown. This event will fire during creation of a View.
+ */
 export type ShownEvent = NamedEvent & {
     type: 'shown';
 };
@@ -35,9 +62,21 @@ export type ShownEvent = NamedEvent & {
  * A View event that does propagate to (republish on) parent topics.
  */
 export type WillPropagateViewEvent = BaseViewEvent & (WillPropagateWebContentsEvent | AttachedEvent | CreatedEvent | DestroyedEvent | HiddenEvent | HotkeyEvent | ShownEvent | TargetChangedEvent);
+/**
+ * A View event.
+ */
 export type ViewEvent = {
     topic: 'view';
 } & (NonPropagatedViewEvent | WillPropagateViewEvent);
+/**
+ * A View event type.
+ */
 export type ViewEventType = ViewEvent['type'];
+/**
+ * A propagated View event.
+ */
 export type PropagatedViewEvent = PropagatedEvent<'view', WillPropagateViewEvent>;
+/**
+ * A propagated View event type.
+ */
 export type PropagatedViewEventType = PropagatedViewEvent['type'];

package/src/api/events/webcontents.d.ts

@@ -7,11 +7,17 @@ type BaseLoadFailedEvent = NamedEvent & {
     validatedURL: string;
     isMainFrame: boolean;
 };
+/**
+ * Generated when an HTTP load was cancelled or failed.
+ */
 export type ResourceLoadFailedEvent = BaseLoadFailedEvent & {
     type: 'resource-load-failed';
 };
+/**
+ * Generated when an HTTP resource request has received response details.
+ */
 export type ResourceResponseReceivedEvent = NamedEvent & {
-    type: 'response-received';
+    type: 'resource-response-received';
     status: boolean;
     newUrl: string;
     originalUrl: string;
@@ -21,25 +27,41 @@ export type ResourceResponseReceivedEvent = NamedEvent & {
     headers: any;
     resourceType: 'mainFrame' | 'subFrame' | 'styleSheet' | 'script' | 'image' | 'object' | 'xhr' | 'other';
 };
+/**
+ * Generated when page title is set during navigation.
+ * @remarks explicitSet is false when title is synthesized from file url.
+ */
 export type PageTitleUpdatedEvent = NamedEvent & {
     type: 'page-title-updated';
     title: string;
 };
+/**
+ * Generated when navigating to a URL that fails certificate validation.
+ */
 export type CertificateErrorEvent = NamedEvent & {
     type: 'certificate-error';
     error: string;
     url: string;
     certificate: OpenFin.Certificate;
 };
+/**
+ * Generated when the certificate selection dialog is shown.
+ */
 export type CertificateSelectionShownEvent = NamedEvent & {
     type: 'certificate-selection-shown';
     url: string;
     certificates: OpenFin.Certificate[];
 };
+/**
+ * Generated when page receives favicon urls.
+ */
 export type FaviconUpdatedEvent = NamedEvent & {
     type: 'page-favicon-updated';
     favicons: string[];
 };
+/**
+ * Generated when view navigation is rejected as per contentNavigation whitelist/blacklist rules.
+ */
 export type NavigationRejectedEvent = NamedEvent & {
     type: 'navigation-rejected';
     sourceName?: string;
@@ -49,6 +71,11 @@ type BaseUrlEvent = NamedEvent & {
     type: 'url-changed';
     url: string;
 };
+/**
+ * Generated when navigation or redirect is completed.
+ * @remarks Also emitted for in-page navigations, examples of this occurring are when anchor links are clicked or when the DOM hashchange event is triggered, indicated by isInPage=true.
+ * Note that navigating to a url with an anchor in it like http://openfin.co/#my-inpage-anchor will fire 2 events indicating the original navigation (isInPage=false) and then the in-page navigation event (isInPage=true).
+ */
 export type UrlChangedEvent = BaseUrlEvent & ({
     isInPage: true;
 } | {
@@ -56,50 +83,89 @@ export type UrlChangedEvent = BaseUrlEvent & ({
     httpResponseCode: number;
     httpStatusText: string;
 });
+/**
+ * Generated when the navigation is done, i.e. the spinner of the tab will stop spinning, and the onload event is dispatched.
+ */
 export type DidFinishLoadEvent = NamedEvent & {
     type: 'did-finish-load';
 };
+/**
+ * Generated when load failed.
+ */
 export type DidFailLoadEvent = BaseLoadFailedEvent & {
     type: 'did-fail-load';
 };
+/**
+ * Generated when a result is available when calling findInPage.
+ */
 export type FoundInPageEvent = NamedEvent & {
     type: 'found-in-page';
 } & {
     result: OpenFin.FindInPageResult;
 };
+/**
+ * Generated when a WebContents loses focus.
+ */
 export type BlurredEvent = NamedEvent & {
     type: 'blurred';
 };
+/**
+ * Generated when a page's theme color changes. This is usually due to encountering a meta tag.
+ */
 export type DidChangeThemeColorEvent = NamedEvent & {
     type: 'did-change-theme-color';
 };
+/**
+ * Generated when a WebContents gains focus.
+ */
 export type FocusedEvent = NamedEvent & {
     type: 'focused';
 };
+/**
+ * Generated when a child content is blocked to load.
+ */
 export type ChildContentBlockedEvent = NamedEvent & {
     type: 'child-content-blocked';
 };
+/**
+ * Generated when a child content is loaded into a browser.
+ */
 export type ChildContentOpenedInBrowserEvent = NamedEvent & {
     type: 'child-content-opened-in-browser';
 };
+/**
+ * Generated when a child View is created.
+ */
 export type ChildViewCreatedEvent = NamedEvent & {
     type: 'child-view-created';
 };
-export type FileDownloadEvent = NamedEvent & {
+/**
+ * A general file download event without event type.
+ */
+export type FileDownloadEvent = {
+    /**
+     * The file download state.
+     */
     state: 'started' | 'progressing' | 'cancelled' | 'interrupted' | 'completed';
     /**
      * The url from which the file is being downloaded.
      */
     url: string;
+    /**
+     * The file mime type.
+     */
     mimeType: string;
     /**
-     * Name used to save the file locally.
+     * The name used to save the file locally.
      */
     fileName: string;
     /**
-     * Original name of the file.
+     * The original name of the file.
      */
     originalFileName: string;
+    /**
+     * The total size in bytes of the file.
+     */
     totalBytes: number;
     /**
      * The number of seconds since the UNIX epoch when the download was started.
@@ -121,15 +187,24 @@ export type FileDownloadEvent = NamedEvent & {
      * The number of bytes of the item that have already been downloaded.
      */
     downloadedBytes: number;
-};
+} & NamedEvent;
+/**
+ * Generated when a file download has started.
+ */
 export type FileDownloadStartedEvent = FileDownloadEvent & {
     type: 'file-download-started';
     state: 'started';
 };
+/**
+ * Generated during file download progress.
+ */
 export type FileDownloadProgressEvent = FileDownloadEvent & {
     type: 'file-download-progress';
     state: 'progressing' | 'interrupted';
 };
+/**
+ * Generated when a file download has completed.
+ */
 export type FileDownloadCompletedEvent = FileDownloadEvent & {
     type: 'file-download-completed';
     state: 'completed' | 'interrupted' | 'cancelled';
@@ -142,5 +217,8 @@ export type WillPropagateWebContentsEvent = BlurredEvent | CertificateSelectionS
  * A WebContents event that does not propagate to (republish on) parent topics.
  */
 export type NonPropagatedWebContentsEvent = FoundInPageEvent | CertificateErrorEvent;
+/**
+ * A WebContents event.
+ */
 export type WebContentsEvent = NonPropagatedWebContentsEvent | WillPropagateWebContentsEvent;
 export {};

package/src/api/events/window.d.ts

@@ -2,11 +2,18 @@ import type * as OpenFin from '../../OpenFin';
 import { NamedEvent, PropagatedEvent } from './base';
 import { BaseViewEvent, PropagatedViewEvent, AttachedEvent as ViewAttachedEvent } from './view';
 import { NonPropagatedWebContentsEvent, WillPropagateWebContentsEvent } from './webcontents';
+/**
+ * Generated when an alert is fired and suppressed due to the customWindowAlert flag being true.
+ */
 export type AlertRequestedEvent = NamedEvent & {
     type: 'alert-requested';
     message: string;
     url: string;
 };
+/**
+ * Generated when a window within this application requires credentials from the user.
+ * @remarks If there is a proxy, please see {@tutorial Proxy.behaviorChange} for more details.
+ */
 export type AuthRequestedEvent = NamedEvent & {
     type: 'auth-requested';
     authInfo: {
@@ -17,48 +24,82 @@ export type AuthRequestedEvent = NamedEvent & {
         scheme: string;
     };
 };
+/**
+ * Generated when a window ends loading.
+ */
 export type EndLoadEvent = NamedEvent & {
     type: 'end-load';
     documentName: string;
     isMain: boolean;
 };
+/**
+ * Generated when window is being redirected as per contentRedirect whitelist/blacklist rules.
+ */
 export type WillRedirectEvent = NamedEvent & {
     type: 'will-redirect';
     blocked: boolean;
     isInPlace: boolean;
     url: string;
 };
+/**
+ * Generated when a window has been reloaded.
+ */
 export type ReloadedEvent = NamedEvent & {
     type: 'reloaded';
     url: string;
 };
+/**
+ * Generated after window options are changed using the window.updateOptions method.
+ * @remarks Will not fire if the diff object is empty.
+ */
 export type WindowOptionsChangedEvent = NamedEvent & {
     type: 'options-changed';
     options: OpenFin.WindowOptions;
     diff: OpenFin.WindowOptionDiff;
 };
+/**
+ * Generated when an external process has exited.
+ */
 export type ExternalProcessExitedEvent = NamedEvent & {
     type: 'external-process-exited';
     processUuid: string;
     exitCode: number;
 };
+/**
+ * Generated when an external process has started.
+ */
 export type ExternalProcessStartedEvent = NamedEvent & {
     type: 'external-process-started';
     processUuid: string;
 };
+/**
+ * Generated when a window has been hidden.
+ */
 export type HiddenEvent = NamedEvent & {
     type: 'hidden';
     reason: 'closing' | 'hide' | 'hide-on-close';
 };
+/**
+ * Preload script running state info during the execution of a window's preload script.
+ */
 export type PreloadScriptInfoRunning = {
     state: 'load-started' | 'load-failed' | 'load-succeeded' | 'failed' | 'succeeded';
 };
+/**
+ * Preload script final state info after the execution of all of a window's preload scripts.
+ */
 export type PreloadScriptInfo = {
     state: 'load-failed' | 'failed' | 'succeeded';
 };
+/**
+ * A general preload scripts state change event without event type.
+ */
 export type PreloadScriptsStateChangeEvent = NamedEvent & {
     preloadScripts: (PreloadScriptInfoRunning & any)[];
 };
+/**
+ * A general user bounds change event without event type.
+ */
 export type UserBoundsChangeEvent = NamedEvent & {
     height: number;
     left: number;
@@ -66,6 +107,9 @@ export type UserBoundsChangeEvent = NamedEvent & {
     width: number;
     windowState: 'minimized' | 'normal' | 'maximized';
 };
+/**
+ * A general bounds change event without event type.
+ */
 export type BoundsChangeEvent = NamedEvent & {
     changeType: 0 | 1 | 2;
     deferred: boolean;
@@ -74,6 +118,9 @@ export type BoundsChangeEvent = NamedEvent & {
     top: number;
     width: number;
 };
+/**
+ * A general will-move or will-resize event without event type.
+ */
 export type WillMoveOrResizeEvent = NamedEvent & {
     height: number;
     left: number;
@@ -81,13 +128,23 @@ export type WillMoveOrResizeEvent = NamedEvent & {
     width: number;
     monitorScaleFactor: number;
 };
+/**
+ * Generated when window finishes loading. Provides performance and navigation data.
+ */
 export type PerformanceReportEvent = Performance & NamedEvent & {
     type: 'performance-report';
 };
+/**
+ * Generated when a window has a view detached from it.
+ * @remarks Will fire when a view is destroyed in which case `target` will be null.
+ */
 export type ViewDetachedEvent = NamedEvent & BaseViewEvent & {
     type: 'view-detached';
     previousTarget: OpenFin.Identity;
 };
+/**
+ * Generated when the value of the element changes.
+ */
 export type InputEvent = {
     inputType: 'keyUp' | 'keyDown';
     ctrlKey: boolean;
@@ -99,12 +156,18 @@ export type InputEvent = {
     repeat: boolean;
     command?: string;
 };
+/**
+ * Generated when a window and all of its layout's views have either finished or failed navigation.
+ */
 export type LayoutInitializedEvent = NamedEvent & {
     type: 'layout-initialized';
     ofViews: (OpenFin.Identity & {
         entityType: 'view';
     })[];
 };
+/**
+ * Generated when a window and all of its layout's views have been created and can receive API calls.
+ */
 export type LayoutReadyEvent = NamedEvent & {
     type: 'layout-ready';
     views: (OpenFin.Identity & {
@@ -115,86 +178,175 @@ export type LayoutReadyEvent = NamedEvent & {
  * A Window event that does not propagate to (republish on) parent topics.
  */
 export type NonPropagatedWindowEvent = NonPropagatedWebContentsEvent;
+/**
+ * Generated at the beginning of a user-driven change to a window's size or position.
+ */
 export type BeginUserBoundsChangingEvent = UserBoundsChangeEvent & {
     type: 'begin-user-bounds-changing';
 };
+/**
+ * Generated after changes in a window's size and/or position.
+ */
 export type BoundsChangedEvent = BoundsChangeEvent & {
     type: 'bounds-changed';
 };
+/**
+ * Generated during changes to a window's size and/or position.
+ */
 export type BoundsChangingEvent = BoundsChangeEvent & {
     type: 'bounds-changing';
 };
+/**
+ * Generated when a window has been prevented from closing.
+ * @remarks A window will be prevented from closing by default, either through the API or by a user when ‘close-requested’ has been subscribed to and the Window.close(force) flag is false.
+ */
 export type WindowCloseRequestedEvent = NamedEvent & {
     type: 'close-requested';
 };
+/**
+ * Generated when a window has closed.
+ */
 export type WindowClosedEvent = NamedEvent & {
     type: 'closed';
 };
+/**
+ * Generated when a window has initiated the closing routine.
+ */
 export type WindowClosingEvent = NamedEvent & {
     type: 'closing';
 };
+/**
+ * Generated after a change to a window's size and/or position is attempted while window movement is disabled.
+ */
 export type DisabledMovementBoundsChangedEvent = BoundsChangeEvent & {
     type: 'disabled-movement-bounds-changed';
 };
+/**
+ * Generated while a change to a window's size and/or position is attempted while window movement is disabled.
+ */
 export type DisabledMovementBoundsChangingEvent = BoundsChangeEvent & {
     type: 'disabled-movement-bounds-changing';
 };
+/**
+ * Generated when a window has been embedded.
+ */
 export type EmbeddedEvent = NamedEvent & {
     type: 'embedded';
 };
+/**
+ * Generated at the end of a user-driven change to a window's size or position.
+ */
 export type EndUserBoundsChangingEvent = UserBoundsChangeEvent & {
     type: 'end-user-bounds-changing';
 };
+/**
+ * Generated when a keyboard shortcut defined in the `hotkeys` array in [Window options](OpenFin.WindowOptions.html) is pressed inside the window.
+ * @remarks For reference on keyboard event properties see [KeyboardEvent](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent).
+ */
 export type WindowHotkeyEvent = InputEvent & NamedEvent & {
     type: 'hotkey';
 };
+/**
+ * Generated when a window is initialized.
+ */
 export type WindowInitializedEvent = NamedEvent & {
     type: 'initialized';
 };
+/**
+ * Generated when a window is maximized.
+ */
 export type MaximizedEvent = NamedEvent & {
     type: 'maximized';
 };
+/**
+ * Generated when a window is minimized.
+ */
 export type MinimizedEvent = NamedEvent & {
     type: 'minimized';
 };
+/**
+ * Generated after the execution of all of a window's preload scripts.
+ * @remarks Contains information about all window's preload scripts' final states.
+ */
 export type PreloadScriptsStateChangedEvent = PreloadScriptsStateChangeEvent & {
     type: 'preload-script-state-changed';
 };
+/**
+ * Generated during the execution of a window's preload script.
+ * @remarks Contains information about a single window's preload script's state, for which the event has been raised.
+ */
 export type PreloadScriptsStateChangingEvent = PreloadScriptsStateChangeEvent & {
     type: 'preload-script-state-changing';
 };
+/**
+ * Generated when a window is displayed after having been minimized or when a window leaves the maximize state without minimizing.
+ */
 export type WindowRestoredEvent = NamedEvent & {
     type: 'restored';
 };
+/**
+ * Generated when a window has been prevented from showing.
+ * @remarks A window will be prevented from showing by default, either through the API or by a user when ‘show-requested’ has been subscribed to on the window or 'window-show-requested' on the parent application and the Window.show(force) flag is false.
+ */
 export type WindowShowRequestedEvent = NamedEvent & {
     type: 'show-requested';
 };
+/**
+ * Generated when a hidden window has been shown.
+ */
 export type WindowShownEvent = NamedEvent & {
     type: 'shown';
 };
+/**
+ * Generated when a window's user movement becomes enabled.
+ */
 export type UserMovementEnabledEvent = NamedEvent & {
     type: 'user-movement-enabled';
 };
+/**
+ * Generated when a window's user movement becomes disabled.
+ */
 export type UserMovementDisabledEvent = NamedEvent & {
     type: 'user-movement-disabled';
 };
+/**
+ * Generated when a window is being moved by the user.
+ * @remarks For use with monitor scaling that is not 100%. Bounds are given in DIP (adjusted for monitor scale factor).
+ */
 export type WillMoveEvent = WillMoveOrResizeEvent & {
     type: 'will-move';
 };
+/**
+ * Generated when a window is being resized by the user.
+ * @remarks For use with monitor scaling that is not 100%. Bounds are given in DIP (adjusted for monitor scale factor).
+ * The event will fire when a user resize is blocked by window options such as maxWidth or minHeight but not if the window is not resizable.
+ */
 export type WillResizeEvent = WillMoveOrResizeEvent & {
     type: 'will-resize';
 };
 /**
- * A propagated view event that is re-propagated from window.
+ * A propagated View event that is re-propagated from window.
  */
 export type PropagatedViewAttachedEvent = PropagatedEvent<'view', ViewAttachedEvent>;
 /**
  * A Window event that does propagate to (republish on) parent topics.
  */
 export type WillPropagateWindowEvent = WillPropagateWebContentsEvent | PropagatedViewAttachedEvent | ViewDetachedEvent | AuthRequestedEvent | BeginUserBoundsChangingEvent | BoundsChangedEvent | BoundsChangingEvent | WindowCloseRequestedEvent | WindowClosedEvent | WindowClosingEvent | DisabledMovementBoundsChangedEvent | DisabledMovementBoundsChangingEvent | EmbeddedEvent | EndUserBoundsChangingEvent | ExternalProcessExitedEvent | ExternalProcessStartedEvent | HiddenEvent | WindowHotkeyEvent | WindowInitializedEvent | LayoutInitializedEvent | LayoutReadyEvent | MaximizedEvent | MinimizedEvent | WindowOptionsChangedEvent | PerformanceReportEvent | PreloadScriptsStateChangedEvent | PreloadScriptsStateChangingEvent | ReloadedEvent | WindowRestoredEvent | WindowShowRequestedEvent | WindowShownEvent | UserMovementDisabledEvent | UserMovementEnabledEvent | WillMoveEvent | WillRedirectEvent | WillResizeEvent;
+/**
+ * A Window event.
+ */
 export type WindowEvent = {
     topic: 'window';
 } & (WillPropagateWindowEvent | NonPropagatedWindowEvent | PropagatedViewEvent);
+/**
+ * A Window event type.
+ */
 export type WindowEventType = WindowEvent['type'];
+/**
+ * A propagated Window event.
+ */
 export type PropagatedWindowEvent = PropagatedEvent<'window', Exclude<WillPropagateWindowEvent, WindowCloseRequestedEvent>>;
+/**
+ * A propagated Window event type.
+ */
 export type PropagatedWindowEventType = PropagatedWindowEvent['type'];

package/src/api/window/Instance.d.ts

@@ -1010,12 +1010,13 @@ export declare class _Window extends WebContents<OpenFin.WindowEvent> {
      */
     /**
      * @typedef {object} MenuItemTemplate
-     * @property {*} data Data to be returned if the user selects the element. Must be serializable. Large objects can have a performance impact.
+     * @property {*} data - Data to be returned if the user selects the element. Must be serializable. Large objects can have a performance impact.
      * @property {'normal' | 'separator' | 'submenu' | 'checkbox'} [type] - Defaults to 'normal' unless a 'submenu' key exists
      * @property {string} [label] - The text to show on the menu item. Should be left undefined for `type: 'separator'`
      * @property {boolean} [enabled] - If false, the menu item will be greyed out and unclickable.
      * @property {boolean} [visible] - If false, the menu item will be entirely hidden.
      * @property {boolean} [checked] - Should only be specified for `checkbox` type menu items.
+     * @property {string} [icon] - Image Data URI with image dimensions inferred from the encoded string
      * @property {Array<MenuItemTemplate>} [submenu] Should be specified for `submenu` type menu items. If `submenu` is specified, the `type: 'submenu'` can be omitted.
      */
     /**

package/src/api/window/Instance.js

@@ -1246,12 +1246,13 @@ class _Window extends main_1.WebContents {
      */
     /**
      * @typedef {object} MenuItemTemplate
-     * @property {*} data Data to be returned if the user selects the element. Must be serializable. Large objects can have a performance impact.
+     * @property {*} data - Data to be returned if the user selects the element. Must be serializable. Large objects can have a performance impact.
      * @property {'normal' | 'separator' | 'submenu' | 'checkbox'} [type] - Defaults to 'normal' unless a 'submenu' key exists
      * @property {string} [label] - The text to show on the menu item. Should be left undefined for `type: 'separator'`
      * @property {boolean} [enabled] - If false, the menu item will be greyed out and unclickable.
      * @property {boolean} [visible] - If false, the menu item will be entirely hidden.
      * @property {boolean} [checked] - Should only be specified for `checkbox` type menu items.
+     * @property {string} [icon] - Image Data URI with image dimensions inferred from the encoded string
      * @property {Array<MenuItemTemplate>} [submenu] Should be specified for `submenu` type menu items. If `submenu` is specified, the `type: 'submenu'` can be omitted.
      */
     /**