@openfin/core 30.73.23 → 30.73.27

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

@@ -1,57 +1,40 @@
 import type * as OpenFin from '../../OpenFin';
-import { CertificateSelectionShownEvent, WebContentsEventMapping, WindowResourceLoadFailedEvent, WindowResourceResponseReceivedEvent } from './webcontents';
-import { BaseEventMap, WindowEvent } from './base';
-import { WindowNavigationRejectedEvent } from './window';
-import { CrashedEvent } from './application';
-export interface ViewEventMapping<Topic = string, Type = string> extends WebContentsEventMapping {
-    'attached': WindowEvent<Topic, Type>;
-    'created': WindowEvent<Topic, Type>;
-    'destroyed': WindowEvent<Topic, Type>;
-    'hidden': WindowEvent<Topic, Type>;
-    'hotkey': InputEvent & WindowEvent<Topic, Type>;
-    'shown': WindowEvent<Topic, Type>;
-    'target-changed': TargetChangedEvent<Topic, Type>;
-}
-interface PropagatedViewIdentity {
-    viewIdentity: OpenFin.Identity;
-}
-export interface PropagatedViewEventMapping<Topic = string, Type = string> extends BaseEventMap {
-    'view-blurred': WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-certificate-selection-shown': CertificateSelectionShownEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-crashed': CrashedEvent & WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-created': CrashedEvent & WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-destroyed': WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-did-change-theme-color': WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-focused': WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-hidden': WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-hotkey': InputEvent & WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-navigation-rejected': WindowNavigationRejectedEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-page-favicon-updated': WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-page-title-updated': WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-resource-load-failed': WindowResourceLoadFailedEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-resource-response-received': WindowResourceResponseReceivedEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-shown': WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-target-changed': TargetChangedEvent<Topic, Type> & PropagatedViewIdentity;
-}
-export declare type ViewEvents = {
-    [Type in keyof ViewEventMapping]: ViewEventMapping<'view', Type>[Type];
-};
-export declare type PropagatedViewEvents<Topic> = {
-    [Type in keyof PropagatedViewEventMapping]: PropagatedViewEventMapping<Topic, Type>[Type];
-};
-export interface InputEvent {
-    inputType: 'keyUp' | 'keyDown';
-    ctrlKey: boolean;
-    shiftKey: boolean;
-    altKey: boolean;
-    metaKey: boolean;
-    key: string;
-    code: string;
-    repeat: boolean;
-    command?: string;
-}
-export interface TargetChangedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+import { NonPropagatedWebContentsEvent, WillPropagateWebContentsEvent } from './webcontents';
+import { NamedEvent, PropagatedEvent } from './base';
+export declare type TargetChangedEvent = NamedEvent & {
+    type: 'target-changed';
     previousTarget: OpenFin.Identity;
     target: OpenFin.Identity;
-}
-export {};
+};
+/**
+ * A View event that does not propagate to (republish on) parent topics.
+ */
+export declare type NonPropagatedViewEvent = NonPropagatedWebContentsEvent;
+export declare type AttachedEvent = NamedEvent & {
+    type: 'attached';
+};
+export declare type CreatedEvent = NamedEvent & {
+    type: 'created';
+};
+export declare type DestroyedEvent = NamedEvent & {
+    type: 'destroyed';
+};
+export declare type HiddenEvent = NamedEvent & {
+    type: 'hidden';
+};
+export declare type HotkeyEvent = NamedEvent & {
+    type: 'hotkey';
+};
+export declare type ShownEvent = NamedEvent & {
+    type: 'shown';
+};
+/**
+ * A View event that does propagate to (republish on) parent topics.
+ */
+export declare type WillPropagateViewEvent = WillPropagateWebContentsEvent | AttachedEvent | CreatedEvent | DestroyedEvent | HiddenEvent | HotkeyEvent | ShownEvent | TargetChangedEvent;
+export declare type ViewEvent = {
+    topic: 'view';
+} & (NonPropagatedViewEvent | WillPropagateViewEvent);
+export declare type ViewEventType = ViewEvent['type'];
+export declare type PropagatedViewEvent = PropagatedEvent<'view', WillPropagateViewEvent>;
+export declare type PropagatedViewEventType = PropagatedViewEvent['type'];

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

@@ -1,14 +1,15 @@
 import type * as OpenFin from '../../OpenFin';
-import { BaseEventMap, WindowEvent } from './base';
+import { NamedEvent } from './base';
 import { CrashedEvent } from './application';
-import { WindowNavigationRejectedEvent } from './window';
-export interface WindowResourceLoadFailedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+export declare type ResourceLoadFailedEvent = NamedEvent & {
+    type: 'resource-load-failed';
     errorCode: number;
     errorDescription: string;
     validatedURL: string;
     isMainFrame: boolean;
-}
-export interface WindowResourceResponseReceivedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type ResourceResponseReceivedEvent = NamedEvent & {
+    type: 'response-received';
     status: boolean;
     newUrl: string;
     originalUrl: string;
@@ -17,33 +18,58 @@ export interface WindowResourceResponseReceivedEvent<Topic, Type> extends Window
     referrer: string;
     headers: any;
     resourceType: 'mainFrame' | 'subFrame' | 'styleSheet' | 'script' | 'image' | 'object' | 'xhr' | 'other';
-}
-export interface PageTitleUpdatedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type PageTitleUpdatedEvent = NamedEvent & {
+    type: 'page-title-updated';
     title: string;
-}
-export interface CertificateErrorEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type CertificateErrorEvent = NamedEvent & {
+    type: 'certificate-error';
     error: string;
     url: string;
     certificate: OpenFin.Certificate;
-}
-export interface CertificateSelectionShownEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type CertificateSelectionShownEvent = NamedEvent & {
+    type: 'certificate-selection-shown';
     url: string;
     certificates: OpenFin.Certificate[];
-}
-export interface FaviconUpdatedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type FaviconUpdatedEvent = NamedEvent & {
+    type: 'page-favicon-updated';
     favicons: string[];
-}
-export interface WebContentsEventMapping<Topic = string, Type = string> extends BaseEventMap {
-    'blurred': WindowEvent<Topic, Type>;
-    'certificate-error': CertificateErrorEvent<Topic, Type>;
-    'certificate-selection-shown': CertificateSelectionShownEvent<Topic, Type>;
-    'crashed': CrashedEvent & WindowEvent<Topic, Type>;
-    'did-change-theme-color': WindowEvent<Topic, Type>;
-    'focused': WindowEvent<Topic, Type>;
-    'found-in-page': WindowEvent<Topic, Type>;
-    'navigation-rejected': WindowNavigationRejectedEvent<Topic, Type>;
-    'page-favicon-updated': FaviconUpdatedEvent<Topic, Type>;
-    'page-title-updated': PageTitleUpdatedEvent<Topic, Type>;
-    'resource-load-failed': WindowResourceLoadFailedEvent<Topic, Type>;
-    'resource-response-received': WindowResourceResponseReceivedEvent<Topic, Type>;
-}
+};
+export declare type NavigationRejectedEvent = NamedEvent & {
+    type: 'navigation-rejected';
+    sourceName?: string;
+    url: string;
+};
+export declare type FoundInPageEvent = NamedEvent & {
+    type: 'found-in-page';
+};
+/**
+ * A WebContents event that does not propagate to (republish on) parent topics.
+ */
+export declare type NonPropagatedWebContentsEvent = FoundInPageEvent | CertificateErrorEvent;
+export declare type BlurredEvent = NamedEvent & {
+    type: 'blurred';
+};
+export declare type DidChangeThemeColorEvent = NamedEvent & {
+    type: 'did-change-theme-color';
+};
+export declare type FocusedEvent = NamedEvent & {
+    type: 'focused';
+};
+export declare type ChildContentBlockedEvent = NamedEvent & {
+    type: 'child-content-blocked';
+};
+export declare type ChildContentOpenedInBrowserEvent = NamedEvent & {
+    type: 'child-content-opened-in-browser';
+};
+export declare type ChildViewCreatedEvent = NamedEvent & {
+    type: 'child-view-created';
+};
+/**
+ * A WebContents event that does propagate to (republish on) parent topics.
+ */
+export declare type WillPropagateWebContentsEvent = BlurredEvent | CertificateSelectionShownEvent | CrashedEvent | DidChangeThemeColorEvent | FocusedEvent | NavigationRejectedEvent | FaviconUpdatedEvent | PageTitleUpdatedEvent | ResourceLoadFailedEvent | ResourceResponseReceivedEvent | ChildContentBlockedEvent | ChildContentOpenedInBrowserEvent | ChildViewCreatedEvent;
+export declare type WebContentsEvent = NonPropagatedWebContentsEvent | WillPropagateWebContentsEvent;

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

@@ -1,13 +1,14 @@
 import type * as OpenFin from '../../OpenFin';
-import { CrashedEvent } from './application';
-import { BaseEventMap, WindowEvent } from './base';
-import { CertificateSelectionShownEvent, WebContentsEventMapping, WindowResourceLoadFailedEvent, WindowResourceResponseReceivedEvent } from './webcontents';
-import { InputEvent, PropagatedViewEventMapping } from './view';
-export interface WindowAlertRequestedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+import { NamedEvent, PropagatedEvent } from './base';
+import { PropagatedViewEvent } from './view';
+import { NonPropagatedWebContentsEvent, WillPropagateWebContentsEvent } from './webcontents';
+export declare type AlertRequestedEvent = NamedEvent & {
+    type: 'alert-requested';
     message: string;
     url: string;
-}
-export interface WindowAuthRequestedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type AuthRequestedEvent = NamedEvent & {
+    type: 'auth-requested';
     authInfo: {
         host: string;
         isProxy: boolean;
@@ -15,165 +16,177 @@ export interface WindowAuthRequestedEvent<Topic, Type> extends WindowEvent<Topic
         realm: string;
         scheme: string;
     };
-}
-export interface WindowEndLoadEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type EndLoadEvent = NamedEvent & {
+    type: 'end-load';
     documentName: string;
     isMain: boolean;
-}
-export interface WindowNavigationRejectedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
-    sourceName?: string;
-    url: string;
-}
-export interface WillRedirectEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type WillRedirectEvent = NamedEvent & {
+    type: 'will-redirect';
     blocked: boolean;
     isInPlace: boolean;
     url: string;
-}
-export interface WindowReloadedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type ReloadedEvent = NamedEvent & {
+    type: 'reloaded';
     url: string;
-}
-export interface WindowOptionsChangedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type WindowOptionsChangedEvent = NamedEvent & {
+    type: 'options-changed';
     options: OpenFin.WindowOptions;
     diff: OpenFin.WindowOptionDiff;
-}
-export interface WindowExternalProcessExitedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type ExternalProcessExitedEvent = NamedEvent & {
+    type: 'external-process-exited';
     processUuid: string;
     exitCode: number;
-}
-export interface WindowExternalProcessStartedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type ExternalProcessStartedEvent = NamedEvent & {
+    type: 'external-process-started';
     processUuid: string;
-}
-export interface WindowHiddenEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type HiddenEvent = NamedEvent & {
+    type: 'hidden';
     reason: 'closing' | 'hide' | 'hide-on-close';
-}
-export interface PreloadScriptInfoRunning {
+};
+export declare type PreloadScriptInfoRunning = {
     state: 'load-started' | 'load-failed' | 'load-succeeded' | 'failed' | 'succeeded';
-}
-export interface PreloadScriptInfo {
+};
+export declare type PreloadScriptInfo = {
     state: 'load-failed' | 'failed' | 'succeeded';
-}
-export interface WindowPreloadScriptsStateChangeEvent<Topic, Type> extends WindowEvent<Topic, Type> {
-    preloadScripts: (PreloadScriptInfoRunning & any)[];
-}
-export interface WindowPreloadScriptsStateChangedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type PreloadScriptsStateChangeEvent = NamedEvent & {
     preloadScripts: (PreloadScriptInfoRunning & any)[];
-}
-export interface WindowBeginBoundsChangingEvent<Topic, Type> extends WindowEvent<Topic, Type> {
-    height: number;
-    left: number;
-    top: number;
-    width: number;
-    windowState: 'minimized' | 'normal' | 'maximized';
-}
-export interface WindowEndBoundsChangingEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type UserBoundsChangeEvent = NamedEvent & {
     height: number;
     left: number;
     top: number;
     width: number;
     windowState: 'minimized' | 'normal' | 'maximized';
-}
-export interface WindowBoundsChange<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type BoundsChangeEvent = NamedEvent & {
     changeType: 0 | 1 | 2;
     deferred: boolean;
     height: number;
     left: number;
     top: number;
     width: number;
-}
-export interface WillMoveOrResize<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type WillMoveOrResizeEvent = NamedEvent & {
     height: number;
     left: number;
     top: number;
     width: number;
     monitorScaleFactor: number;
-}
-export declare type WindowPerformanceReport<Topic, Type> = Performance & WindowEvent<Topic, Type>;
-export interface ViewDetached<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type PerformanceReportEvent = Performance & NamedEvent & {
+    type: 'performance-report';
+};
+export declare type ViewDetachedEvent = NamedEvent & {
+    type: 'view-detached';
     previousTarget: OpenFin.Identity;
     target: OpenFin.Identity;
     viewIdentity: OpenFin.Identity;
-}
-export interface WindowEventMapping<Topic = string, Type = string> extends WebContentsEventMapping {
-    'auth-requested': WindowAuthRequestedEvent<Topic, Type>;
-    'begin-user-bounds-changing': WindowBeginBoundsChangingEvent<Topic, Type>;
-    'bounds-changed': WindowBoundsChange<Topic, Type>;
-    'bounds-changing': WindowBoundsChange<Topic, Type>;
-    'close-requested': WindowEvent<Topic, Type>;
-    'closed': WindowEvent<Topic, Type>;
-    'closing': WindowEvent<Topic, Type>;
-    'disabled-movement-bounds-changed': WindowBoundsChange<Topic, Type>;
-    'disabled-movement-bounds-changing': WindowBoundsChange<Topic, Type>;
-    'embedded': WindowEvent<Topic, Type>;
-    'end-user-bounds-changing': WindowEndBoundsChangingEvent<Topic, Type>;
-    'external-process-exited': WindowExternalProcessExitedEvent<Topic, Type>;
-    'external-process-started': WindowExternalProcessStartedEvent<Topic, Type>;
-    'hidden': WindowHiddenEvent<Topic, Type>;
-    'hotkey': InputEvent & WindowEvent<Topic, Type>;
-    'initialized': WindowEvent<Topic, Type>;
-    'layout-initialized': WindowEvent<Topic, Type>;
-    'layout-ready': WindowEvent<Topic, Type>;
-    'maximized': WindowEvent<Topic, Type>;
-    'minimized': WindowEvent<Topic, Type>;
-    'options-changed': WindowOptionsChangedEvent<Topic, Type>;
-    'performance-report': WindowPerformanceReport<Topic, Type>;
-    'preload-scripts-state-changed': WindowPreloadScriptsStateChangeEvent<Topic, Type>;
-    'preload-scripts-state-changing': WindowPreloadScriptsStateChangeEvent<Topic, Type>;
-    'reloaded': WindowReloadedEvent<Topic, Type>;
-    'restored': WindowEvent<Topic, Type>;
-    'show-requested': WindowEvent<Topic, Type>;
-    'shown': WindowEvent<Topic, Type>;
-    'user-movement-disabled': WindowEvent<Topic, Type>;
-    'user-movement-enabled': WindowEvent<Topic, Type>;
-    'view-attached': WindowEvent<Topic, Type>;
-    'view-detached': ViewDetached<Topic, Type>;
-    'will-move': WillMoveOrResize<Topic, Type>;
-    'will-redirect': WillRedirectEvent<Topic, Type>;
-    'will-resize': WillMoveOrResize<Topic, Type>;
-}
-export interface PropagatedWindowEventMapping<Topic = string, Type = string> extends BaseEventMap {
-    'window-begin-user-bounds-changing': WindowBeginBoundsChangingEvent<Topic, Type>;
-    'window-blurred': WindowEvent<Topic, Type>;
-    'window-bounds-changed': WindowBoundsChange<Topic, Type>;
-    'window-bounds-changing': WindowBoundsChange<Topic, Type>;
-    'window-certificate-selection-shown': CertificateSelectionShownEvent<Topic, Type>;
-    'window-closed': WindowEvent<Topic, Type>;
-    'window-closing': WindowEvent<Topic, Type>;
-    'window-crashed': CrashedEvent & WindowEvent<Topic, Type>;
-    'window-disabled-movement-bounds-changed': WindowBoundsChange<Topic, Type>;
-    'window-disabled-movement-bounds-changing': WindowBoundsChange<Topic, Type>;
-    'window-embedded': WindowEvent<Topic, Type>;
-    'window-end-user-bounds-changing': WindowBeginBoundsChangingEvent<Topic, Type>;
-    'window-external-process-exited': WindowExternalProcessExitedEvent<Topic, Type>;
-    'window-external-process-started': WindowExternalProcessStartedEvent<Topic, Type>;
-    'window-focused': WindowEvent<Topic, Type>;
-    'window-hidden': WindowHiddenEvent<Topic, Type>;
-    'window-hotkey': InputEvent & WindowEvent<Topic, Type>;
-    'window-initialized': WindowEvent<Topic, Type>;
-    'window-layout-initialized': WindowEvent<Topic, Type>;
-    'window-layout-ready': WindowEvent<Topic, Type>;
-    'window-maximized': WindowEvent<Topic, Type>;
-    'window-minimized': WindowEvent<Topic, Type>;
-    'window-navigation-rejected': WindowNavigationRejectedEvent<Topic, Type>;
-    'window-options-changed': WindowOptionsChangedEvent<Topic, Type>;
-    'window-performance-report': WindowPerformanceReport<Topic, Type>;
-    'window-preload-scripts-state-changed': WindowPreloadScriptsStateChangeEvent<Topic, Type>;
-    'window-preload-scripts-state-changing': WindowPreloadScriptsStateChangedEvent<Topic, Type>;
-    'window-resource-load-failed': WindowResourceLoadFailedEvent<Topic, Type>;
-    'window-resource-response-received': WindowResourceResponseReceivedEvent<Topic, Type>;
-    'window-reloaded': WindowReloadedEvent<Topic, Type>;
-    'window-restored': WindowEvent<Topic, Type>;
-    'window-shown': WindowEvent<Topic, Type>;
-    'window-user-movement-disabled': WindowEvent<Topic, Type>;
-    'window-user-movement-enabled': WindowEvent<Topic, Type>;
-    'window-view-attached': WindowEvent<Topic, Type>;
-    'window-view-detached': ViewDetached<Topic, Type>;
-    'window-will-move': WillMoveOrResize<Topic, Type>;
-    'window-will-redirect': WillRedirectEvent<Topic, Type>;
-    'window-will-resize': WillMoveOrResize<Topic, Type>;
-}
-export declare type WindowEvents = PropagatedViewEventMapping<'window'> & {
-    [Type in keyof WindowEventMapping]: WindowEventMapping<'window', Type>[Type];
-};
-export declare type PropagatedWindowEvents<Topic> = {
-    [Type in keyof PropagatedWindowEventMapping]: PropagatedWindowEventMapping<Topic, Type>[Type];
 };
+export declare type InputEvent = {
+    inputType: 'keyUp' | 'keyDown';
+    ctrlKey: boolean;
+    shiftKey: boolean;
+    altKey: boolean;
+    metaKey: boolean;
+    key: string;
+    code: string;
+    repeat: boolean;
+    command?: string;
+};
+/**
+ * A Window event that does not propagate to (republish on) parent topics.
+ */
+export declare type NonPropagatedWindowEvent = NonPropagatedWebContentsEvent;
+export declare type BeginUserBoundsChangingEvent = UserBoundsChangeEvent & {
+    type: 'begin-user-bounds-changing';
+};
+export declare type BoundsChangedEvent = BoundsChangeEvent & {
+    type: 'bounds-changed';
+};
+export declare type BoundsChangingEvent = BoundsChangeEvent & {
+    type: 'bounds-changing';
+};
+export declare type WindowCloseRequestedEvent = NamedEvent & {
+    type: 'close-requested';
+};
+export declare type WindowClosedEvent = NamedEvent & {
+    type: 'closed';
+};
+export declare type WindowClosingEvent = NamedEvent & {
+    type: 'closing';
+};
+export declare type DisabledMovementBoundsChangedEvent = BoundsChangeEvent & {
+    type: 'disabled-movement-bounds-changed';
+};
+export declare type DisabledMovementBoundsChangingEvent = BoundsChangeEvent & {
+    type: 'disabled-movement-bounds-changing';
+};
+export declare type EmbeddedEvent = NamedEvent & {
+    type: 'embedded';
+};
+export declare type EndUserBoundsChangingEvent = UserBoundsChangeEvent & {
+    type: 'end-user-bounds-changing';
+};
+export declare type WindowHotkeyEvent = InputEvent & NamedEvent & {
+    type: 'hotkey';
+};
+export declare type WindowInitializedEvent = NamedEvent & {
+    type: 'initialized';
+};
+export declare type LayoutInitializedEvent = NamedEvent & {
+    type: 'layout-initialized';
+};
+export declare type LayoutReadyEvent = NamedEvent & {
+    type: 'layout-ready';
+};
+export declare type MaximizedEvent = NamedEvent & {
+    type: 'maximized';
+};
+export declare type MinimizedEvent = NamedEvent & {
+    type: 'minimized';
+};
+export declare type PreloadScriptsStateChangedEvent = PreloadScriptsStateChangeEvent & {
+    type: 'preload-script-state-changed';
+};
+export declare type PreloadScriptsStateChangingEvent = PreloadScriptsStateChangeEvent & {
+    type: 'preload-script-state-changing';
+};
+export declare type WindowRestoredEvent = NamedEvent & {
+    type: 'restored';
+};
+export declare type WindowShowRequestedEvent = NamedEvent & {
+    type: 'show-requested';
+};
+export declare type WindowShownEvent = NamedEvent & {
+    type: 'shown';
+};
+export declare type UserMovementEnabledEvent = NamedEvent & {
+    type: 'user-movement-enabled';
+};
+export declare type UserMovementDisabledEvent = NamedEvent & {
+    type: 'user-movement-disabled';
+};
+export declare type WillMoveEvent = WillMoveOrResizeEvent & {
+    type: 'will-move';
+};
+export declare type WillResizeEvent = WillMoveOrResizeEvent & {
+    type: 'will-resize';
+};
+/**
+ * A Window event that does propagate to (republish on) parent topics.
+ */
+export declare type WillPropagateWindowEvent = WillPropagateWebContentsEvent | PropagatedViewEvent | 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;
+export declare type WindowEvent = {
+    topic: 'window';
+} & (WillPropagateWindowEvent | NonPropagatedWindowEvent);
+export declare type WindowEventType = WindowEvent['type'];
+export declare type PropagatedWindowEvent = PropagatedEvent<'window', WillPropagateWindowEvent>;
+export declare type PropagatedWindowEventType = PropagatedWindowEvent['type'];

package/src/api/external-application/Instance.d.ts

@@ -13,7 +13,7 @@ import Transport from '../../transport/transport';
  * @class
  * @hideconstructor
  */
-export declare class ExternalApplication extends EmitterBase<OpenFin.ExternalApplicationEvents> {
+export declare class ExternalApplication extends EmitterBase<OpenFin.ExternalApplicationEvent> {
     identity: OpenFin.ApplicationIdentity;
     constructor(wire: Transport, identity: OpenFin.ApplicationIdentity);
     /**

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

@@ -1,7 +1,7 @@
 import type * as OpenFin from '../../OpenFin';
 import { EmitterBase } from '../base';
 import Transport from '../../transport/transport';
-declare type FrameEvents = OpenFin.FrameEvents;
+declare type FrameEvents = OpenFin.FrameEvent;
 /**
  * @classdesc
  * An iframe represents an embedded HTML page within a parent HTML page. Because this embedded page

package/src/api/global-hotkey/index.d.ts

@@ -1,12 +1,11 @@
 import type * as OpenFin from '../../OpenFin';
 import { EmitterBase } from '../base';
 import Transport from '../../transport/transport';
-declare type GlobalHotkeyEvents = OpenFin.GlobalHotkeyEvents;
 /**
  * The GlobalHotkey module can register/unregister a global hotkeys.
  * @namespace
  */
-export default class GlobalHotkey extends EmitterBase<GlobalHotkeyEvents> {
+export default class GlobalHotkey extends EmitterBase<OpenFin.GlobalHotkeyEvent> {
     constructor(wire: Transport);
     /**
      * Registers a global hotkey with the operating system.
@@ -37,4 +36,3 @@ export default class GlobalHotkey extends EmitterBase<GlobalHotkeyEvents> {
      */
     isRegistered(hotkey: string): Promise<boolean>;
 }
-export {};

package/src/api/global-hotkey/index.js

@@ -17,6 +17,8 @@ class GlobalHotkey extends base_1.EmitterBase {
      * @tutorial GlobalHotkey.register
      */
     async register(hotkey, listener) {
+        // TODO: fix typing (hotkey events are not typed)
+        // @ts-expect-error
         await this.on(hotkey, listener);
         await this.wire.sendAction('global-hotkey-register', { hotkey });
         return undefined;
@@ -28,6 +30,8 @@ class GlobalHotkey extends base_1.EmitterBase {
      * @tutorial GlobalHotkey.unregister
      */
     async unregister(hotkey) {
+        // TODO: fix typing (hotkey events are not typed)
+        // @ts-expect-error
         await this.removeAllListeners(hotkey);
         await this.wire.sendAction('global-hotkey-unregister', { hotkey });
         return undefined;
@@ -40,6 +44,8 @@ class GlobalHotkey extends base_1.EmitterBase {
     async unregisterAll() {
         await Promise.all(this.eventNames()
             .filter((name) => !(name === 'registered' || name === 'unregistered'))
+            // TODO: fix typing (hotkey events are not typed)
+            // @ts-expect-error
             .map((name) => this.removeAllListeners(name)));
         await this.wire.sendAction('global-hotkey-unregister-all', {});
         return undefined;

package/src/api/interappbus/channel/index.d.ts

@@ -3,7 +3,7 @@ import ChannelClient from './client';
 import { ChannelProvider } from './provider';
 import { EmitterBase } from '../../base';
 import Transport, { Message } from '../../../transport/transport';
-import { ChannelEvents } from '../../events/channel';
+import { ChannelEvent } from '../../events/channel';
 declare type ProviderIdentity = OpenFin.ProviderIdentity;
 declare type Identity = OpenFin.Identity;
 export interface ChannelMessage extends Message<any> {
@@ -12,7 +12,7 @@ export interface ChannelMessage extends Message<any> {
     providerIdentity: ProviderIdentity;
     connectAction: boolean;
 }
-export declare class Channel extends EmitterBase<ChannelEvents> {
+export declare class Channel extends EmitterBase<ChannelEvent> {
     #private;
     constructor(wire: Transport);
     getAllChannels(): Promise<ProviderIdentity[]>;

package/src/api/interappbus/channel/index.js

@@ -120,6 +120,8 @@ class Channel extends base_1.EmitterBase {
         }
         const { payload: { data: providerIdentity } } = await this.wire.sendAction('create-channel', { channelName });
         const channel = __classPrivateFieldGet(this, _Channel_connectionManager, "f").createProvider(options, providerIdentity);
+        // TODO: fix typing (internal)
+        // @ts-expect-error
         this.on('client-disconnected', (eventPayload) => {
             if (eventPayload.channelName === channelName) {
                 provider_1.ChannelProvider.handleClientDisconnection(channel, eventPayload);

package/src/api/platform/Factory.js

@@ -145,6 +145,8 @@ class PlatformModule extends base_1.Base {
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                 // @ts-ignore using private variable.
                 const app = await this.fin.Application._create({ ...platformOptions, isPlatformController: true });
+                // TODO: fix typing (internal)
+                // @ts-expect-error
                 app.once('platform-api-ready', () => resolve(this.wrapSync({ uuid })));
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                 // @ts-ignore using private variable.
@@ -174,6 +176,8 @@ class PlatformModule extends base_1.Base {
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                 // @ts-ignore using private variable.
                 const app = await this.fin.Application._createFromManifest(manifestUrl);
+                // TODO: fix typing (internal)
+                // @ts-expect-error
                 app.once('platform-api-ready', () => resolve(this.wrapSync({ uuid: app.identity.uuid })));
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                 // @ts-ignore using private method without warning.